@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/swappers/NearIntentsSwapper/endpoints.js

@@ -1,154 +1,32 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
-import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
-import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
-import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
+import { createDefaultStatusResponse, getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote, } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
-import { getNearIntentsStatusMessage, mapNearIntentsStatus } from './utils/helpers/helpers.js';
+import { getNearIntentsStatusMessage, mapNearIntentsStatus } from './utils/helpers.js';
 import { initializeOneClickService, OneClickService } from './utils/oneClickService.js';
 export const nearIntentsApi = {
-    getTradeQuote,
-    getTradeRate: (input, deps) => {
-        return getTradeRate(input, deps);
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const data = evm.getErc20Data(to, value, contractAddress);
-        const feeData = await evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
-        return adapter.buildSendApiTransaction({
-            accountNumber,
-            from,
-            to,
-            value,
-            chainSpecific: { contractAddress, ...feeData },
-        });
-    },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const data = evm.getErc20Data(to, value, contractAddress);
-        const feeData = await evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
-    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, assertGetUtxoChainAdapter, xpub, accountType, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, accountNumber, nearIntentsSpecific, feeData } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
-        if (!xpub)
-            throw new Error('xpub is required for UTXO transactions');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const satoshiPerByte = feeData.chainSpecific?.satsPerByte ?? '0';
-        return adapter.buildSendApiTransaction({
-            accountNumber,
-            to: nearIntentsSpecific.depositAddress,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            sendMax: false,
-            chainSpecific: {
-                satoshiPerByte,
-                accountType,
-            },
-            xpub,
-        });
-    },
-    getUtxoTransactionFees: ({ tradeQuote, stepIndex }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        if (!step.feeData.networkFeeCryptoBaseUnit) {
-            throw new Error('Missing network fee in quote');
-        }
-        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
-    },
-    getUnsignedSolanaTransaction: async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
-        const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const tokenId = contractAddressOrUndefined(sellAsset.assetId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value,
-            chainSpecific: { from, tokenId },
-        });
-        return adapter.buildSendApiTransaction({
-            to,
-            from,
-            value,
-            accountNumber,
-            chainSpecific: tokenId
-                ? {
-                    // For SPL tokens: include compute budget parameters
-                    tokenId,
-                    computeUnitLimit: fast.chainSpecific.computeUnits,
-                    computeUnitPrice: fast.chainSpecific.priorityFee,
-                }
-                : {
-                    // For native SOL: no compute budget needed for simple transfers
-                    tokenId,
-                },
-        });
-    },
-    getSolanaTransactionFees: ({ tradeQuote, stepIndex }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        if (!step.feeData.networkFeeCryptoBaseUnit) {
-            throw new Error('Missing network fee in quote');
-        }
-        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
-    },
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
+    getUnsignedSolanaTransaction,
+    getSolanaTransactionFees,
     getUnsignedTronTransaction,
     getTronTransactionFees,
     getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
+        const { accountNumber, sellAsset } = step;
+        const { depositAddress } = getSwapMetadata(step.swapperMetadata, 'nearIntents');
         const adapter = assertGetSuiChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
+        const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const tokenId = contractAddressOrUndefined(sellAsset.assetId);
         const { fast } = await adapter.getFeeData({
@@ -181,11 +59,10 @@ export const nearIntentsApi = {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
+        const { accountNumber, sellAsset } = step;
+        const { depositAddress } = getSwapMetadata(step.swapperMetadata, 'nearIntents');
         const adapter = assertGetNearChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
+        const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
         return await adapter.buildSendApiTransaction({
@@ -209,11 +86,10 @@ export const nearIntentsApi = {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
+        const { accountNumber, sellAsset } = step;
+        const { depositAddress } = getSwapMetadata(step.swapperMetadata, 'nearIntents');
         const adapter = assertGetStarknetChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
+        const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const tokenContractAddress = contractAddressOrUndefined(sellAsset.assetId);
         const { fast } = await adapter.getFeeData({
@@ -249,11 +125,10 @@ export const nearIntentsApi = {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
-        if (!nearIntentsSpecific)
-            throw new Error('nearIntentsSpecific is required');
+        const { accountNumber, sellAsset } = step;
+        const { depositAddress, depositMemo } = getSwapMetadata(step.swapperMetadata, 'nearIntents');
         const adapter = assertGetTonChainAdapter(sellAsset.chainId);
-        const to = nearIntentsSpecific.depositAddress;
+        const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
         return adapter.buildSendApiTransaction({
@@ -263,7 +138,7 @@ export const nearIntentsApi = {
             accountNumber,
             chainSpecific: {
                 contractAddress,
-                memo: nearIntentsSpecific.depositMemo,
+                memo: depositMemo,
             },
         });
     },
@@ -277,22 +152,24 @@ export const nearIntentsApi = {
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
     checkTradeStatus: async ({ config, swap }) => {
-        const { nearIntentsSpecific } = swap?.metadata ?? {};
-        if (!nearIntentsSpecific?.depositAddress) {
-            return createDefaultStatusResponse(swap?.buyTxHash);
-        }
+        if (!swap)
+            throw new Error('Missing swap');
+        const { depositAddress } = getSwapMetadata(swap.metadata.swapperMetadata, 'nearIntents');
         initializeOneClickService(config.VITE_NEAR_INTENTS_API_KEY);
         try {
             // TODO(gomes): SDK doesn't support depositMemo yet in getExecutionStatus
-            const statusResponse = await OneClickService.getExecutionStatus(nearIntentsSpecific.depositAddress);
+            const statusResponse = await OneClickService.getExecutionStatus(depositAddress);
             const txStatus = mapNearIntentsStatus(statusResponse.status);
             const message = getNearIntentsStatusMessage(statusResponse.status);
             // Extract buyTxHash from destination chain transactions
             const buyTxHash = statusResponse.swapDetails?.destinationChainTxHashes?.[0]?.hash;
-            const actualBuyAmountCryptoBaseUnit = statusResponse.swapDetails?.amountOut;
+            // amountOut is only meaningful destination-denominated on terminal success - in-flight and
+            // refund states may carry settlement-internal or refund values
+            const actualBuyAmountCryptoBaseUnit = statusResponse.status === 'SUCCESS' ? statusResponse.swapDetails?.amountOut : undefined;
             return {
                 status: txStatus,
                 buyTxHash,
+                swapperTxLink: `https://explorer.near-intents.org/transactions/${depositAddress}`,
                 message,
                 actualBuyAmountCryptoBaseUnit,
             };

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
-export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { NearIntentsTradeQuoteInput } from '../types.js';
+export declare const getTradeQuote: (input: NearIntentsTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.js

@@ -1,325 +1,74 @@
-import { btcChainId, CHAIN_NAMESPACE, fromAssetId, nearChainId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero, chainIdToFeeAssetId, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { BTC_QUOTE_DEADLINE_MS, DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS, } from '../constants.js';
+import { assertQuoteAddresses } from '../../../utils/index.js';
 import { QuoteRequest } from '../types.js';
-import { assetToNearIntentsAsset, calculateAccountCreationCosts } from '../utils/helpers/helpers.js';
-import { ApiError, initializeOneClickService, OneClickService } from '../utils/oneClickService.js';
+import { getNearIntentsStepData } from '../utils/getNearIntentsStepData.js';
+import { getNearIntentsTradeContext } from '../utils/getNearIntentsTradeContext.js';
+import { buildNearIntentsQuoteRequest, fetchNearIntentsQuote, getNearIntentsQuoteDeadline, resolveNearIntentsAssets, } from '../utils/helpers.js';
+import { initializeOneClickService } from '../utils/oneClickService.js';
 export const getTradeQuote = async (input, deps) => {
-    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, } = input;
-    if (accountNumber === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `accountNumber is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (sendAddress === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `sendAddress is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (receiveAddress === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `receiveAddress is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    const from = sendAddress;
-    try {
-        initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
-        const originAsset = await assetToNearIntentsAsset(sellAsset);
-        const destinationAsset = await assetToNearIntentsAsset(buyAsset);
-        if (!originAsset) {
-            return Err(makeSwapErrorRight({
-                code: TradeQuoteError.UnsupportedTradePair,
-                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
-            }));
-        }
-        if (!destinationAsset) {
-            return Err(makeSwapErrorRight({
-                code: TradeQuoteError.UnsupportedTradePair,
-                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
-            }));
-        }
-        const quoteDeadline = sellAsset.chainId === btcChainId || buyAsset.chainId === btcChainId
-            ? BTC_QUOTE_DEADLINE_MS
-            : DEFAULT_QUOTE_DEADLINE_MS;
-        const quoteRequest = {
-            dry: false,
-            swapType: QuoteRequest.swapType.EXACT_INPUT,
-            slippageTolerance: slippageTolerancePercentageDecimal
-                ? bnOrZero(slippageTolerancePercentageDecimal).times(10000).toNumber()
-                : DEFAULT_SLIPPAGE_BPS,
-            originAsset,
-            destinationAsset,
-            amount: sellAmount,
-            depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
-            refundTo: sendAddress,
-            refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
-            recipient: receiveAddress,
-            recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
-            deadline: new Date(Date.now() + quoteDeadline).toISOString(),
-            referral: 'shapeshift',
-            appFees: [
-                {
-                    recipient: DAO_TREASURY_NEAR,
-                    fee: Number(affiliateBps),
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, } = input;
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
+    const maybeAssets = await resolveNearIntentsAssets({ sellAsset, buyAsset });
+    if (maybeAssets.isErr())
+        return Err(maybeAssets.unwrapErr());
+    const { originAsset, destinationAsset } = maybeAssets.unwrap();
+    const quoteRequest = buildNearIntentsQuoteRequest({
+        originAsset,
+        destinationAsset,
+        sellAmountCryptoBaseUnit: sellAmount,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        affiliateBps,
+        refundTo: sendAddress,
+        recipient: receiveAddress,
+        refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
+        recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
+        deadline: getNearIntentsQuoteDeadline({ sellAsset, buyAsset }),
+    });
+    const maybeQuoteResponse = await fetchNearIntentsQuote({ quoteRequest, sellAsset });
+    if (maybeQuoteResponse.isErr())
+        return Err(maybeQuoteResponse.unwrapErr());
+    const { quote } = maybeQuoteResponse.unwrap();
+    const maybeContext = getNearIntentsTradeContext({ input, deps, quote });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getNearIntentsStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const requestDeadlineMs = Date.parse(quoteRequest.deadline);
+    const responseDeadlineMs = Date.parse(quote.deadline ?? '');
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        // Deposits mined after our requested refund deadline refund instead of executing as quoted;
+        // the response deadline (when the deposit address goes inactive, ~72h) only binds if tighter
+        deadline: Number.isFinite(responseDeadlineMs)
+            ? Math.min(requestDeadlineMs, responseDeadlineMs)
+            : requestDeadlineMs,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { protocolFees, networkFeeCryptoBaseUnit },
+                swapperMetadata: {
+                    name: 'nearIntents',
+                    depositAddress: quote.depositAddress ?? '',
+                    depositMemo: quote.depositMemo,
                 },
-            ],
-        };
-        const maxRetries = 3;
-        let quoteResponse = null;
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                quoteResponse = await OneClickService.getQuote(quoteRequest);
-                break;
-            }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                const isWebSocketError = lastError.message.includes('WebSocket is not ready');
-                if (isWebSocketError && attempt < maxRetries) {
-                    await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
-                    continue;
-                }
-                throw lastError;
-            }
-        }
-        if (!quoteResponse) {
-            throw lastError ?? new Error('Failed to get quote after retries');
-        }
-        const { quote } = quoteResponse;
-        if (!quote.depositAddress) {
-            throw new Error('Missing deposit address in quote response');
-        }
-        const { chainNamespace } = fromAssetId(sellAsset.assetId);
-        const depositAddress = quote.depositAddress;
-        const getFeeData = async () => {
-            switch (chainNamespace) {
-                case CHAIN_NAMESPACE.Evm: {
-                    const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
-                    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                    const data = evm.getErc20Data(depositAddress, sellAmount, contractAddress);
-                    const feeData = await sellAdapter.getFeeData({
-                        to: contractAddress ?? depositAddress,
-                        value: isNativeEvmAsset(sellAsset.assetId) ? sellAmount : '0',
-                        chainSpecific: {
-                            from,
-                            contractAddress,
-                            data: data || '0x',
-                        },
-                        sendMax: false,
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                case CHAIN_NAMESPACE.Utxo: {
-                    const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
-                    const pubkey = input.xpub;
-                    if (!pubkey) {
-                        return {
-                            networkFeeCryptoBaseUnit: undefined,
-                        };
-                    }
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: { pubkey },
-                        sendMax: false,
-                    });
-                    return {
-                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
-                        chainSpecific: {
-                            satsPerByte: feeData.fast.chainSpecific.satoshiPerByte,
-                        },
-                    };
-                }
-                case CHAIN_NAMESPACE.Solana: {
-                    const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-                    const tokenId = isToken(sellAsset.assetId)
-                        ? fromAssetId(sellAsset.assetId).assetReference
-                        : undefined;
-                    const instructions = await sellAdapter.buildEstimationInstructions({
-                        from,
-                        to: depositAddress,
-                        tokenId,
-                        value: sellAmount,
-                    });
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: {
-                            from,
-                            tokenId,
-                            instructions,
-                        },
-                        sendMax: false,
-                    });
-                    const txFee = feeData.fast.txFee;
-                    const ataCreationCost = calculateAccountCreationCosts(instructions);
-                    const totalFee = bn(txFee).plus(ataCreationCost).toString();
-                    return { networkFeeCryptoBaseUnit: totalFee };
-                }
-                case CHAIN_NAMESPACE.Tron: {
-                    const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
-                    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: {
-                            from: sendAddress,
-                            contractAddress,
-                        },
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                case CHAIN_NAMESPACE.Sui: {
-                    const sellAdapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
-                    const tokenId = isToken(sellAsset.assetId)
-                        ? fromAssetId(sellAsset.assetId).assetReference
-                        : undefined;
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: {
-                            from,
-                            tokenId,
-                        },
-                        sendMax: false,
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                case CHAIN_NAMESPACE.Near: {
-                    const sellAdapter = deps.assertGetNearChainAdapter(sellAsset.chainId);
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: { from },
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                case CHAIN_NAMESPACE.Starknet: {
-                    const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
-                    const tokenContractAddress = isToken(sellAsset.assetId)
-                        ? fromAssetId(sellAsset.assetId).assetReference
-                        : undefined;
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: {
-                            from,
-                            tokenContractAddress,
-                        },
-                        sendMax: false,
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                case CHAIN_NAMESPACE.Ton: {
-                    const sellAdapter = deps.assertGetTonChainAdapter(sellAsset.chainId);
-                    const contractAddress = isToken(sellAsset.assetId)
-                        ? fromAssetId(sellAsset.assetId).assetReference
-                        : undefined;
-                    const feeData = await sellAdapter.getFeeData({
-                        to: depositAddress,
-                        value: sellAmount,
-                        chainSpecific: {
-                            from,
-                            contractAddress,
-                        },
-                    });
-                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
-                }
-                default:
-                    throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
-            }
-        };
-        const { networkFeeCryptoBaseUnit, chainSpecific } = await getFeeData();
-        const rate = getInputOutputRate({
-            sellAmountCryptoBaseUnit: quote.amountIn,
-            buyAmountCryptoBaseUnit: quote.amountOut,
-            sellAsset,
-            buyAsset,
-        });
-        const tradeQuote = {
-            id: uuid(),
-            receiveAddress,
-            affiliateBps,
-            rate,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
-                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.NearIntents),
-            quoteOrRate: 'quote',
-            swapperName: SwapperName.NearIntents,
-            steps: [
-                {
-                    accountNumber,
-                    allowanceContract: '',
-                    buyAmountBeforeFeesCryptoBaseUnit: quote.amountOut,
-                    buyAmountAfterFeesCryptoBaseUnit: quote.amountOut,
-                    buyAsset,
-                    feeData: {
-                        protocolFees: {},
-                        networkFeeCryptoBaseUnit,
-                        ...(chainSpecific && { chainSpecific }),
-                    },
-                    rate,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: quote.amountIn,
-                    sellAsset,
-                    source: SwapperName.NearIntents,
-                    estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
-                    nearIntentsSpecific: {
-                        depositAddress: quote.depositAddress ?? '',
-                        depositMemo: quote.depositMemo,
-                        timeEstimate: quote.timeEstimate,
-                        deadline: quote.deadline ?? '',
-                    },
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'fixed_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: quote.amountIn,
-                        buyAmountCryptoBaseUnit: quote.amountOut,
-                        fixedAssetId: chainIdToFeeAssetId(nearChainId),
-                        fixedAsset: deps.assetsById[chainIdToFeeAssetId(nearChainId)],
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return Ok([tradeQuote]);
-    }
-    catch (error) {
-        console.error('[NEAR Intents] getTradeQuote error:', error);
-        if (error instanceof ApiError) {
-            if (error.body?.message === 'tokenIn is not valid' ||
-                error.body?.message === 'tokenOut is not valid') {
-                return Err(makeSwapErrorRight({
-                    code: TradeQuoteError.UnsupportedTradePair,
-                    message: 'Unsupported asset',
-                }));
-            }
-            if (error.body?.message?.includes('Amount is too low')) {
-                const match = error.body.message.match(/try at least (\d+)/);
-                if (match) {
-                    const minAmountCryptoBaseUnit = match[1];
-                    return Err(createTradeAmountTooSmallErr({
-                        minAmountCryptoBaseUnit,
-                        assetId: sellAsset.assetId,
-                    }));
-                }
-            }
-        }
-        return Err(makeSwapErrorRight({
-            message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents quote',
-            code: TradeQuoteError.QueryFailed,
-            cause: error,
-        }));
-    }
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
 };