@shapeshiftoss/swapper 17.6.4 → 17.6.6-alpha.0

package/dist/esm/constants.js

@@ -13,6 +13,8 @@ import { jupiterApi } from './swappers/JupiterSwapper/endpoints.js';
 import { jupiterSwapper } from './swappers/JupiterSwapper/JupiterSwapper.js';
 import { mayachainApi } from './swappers/MayachainSwapper/endpoints.js';
 import { mayachainSwapper } from './swappers/MayachainSwapper/MayachainSwapper.js';
+import { nearIntentsApi } from './swappers/NearIntentsSwapper/endpoints.js';
+import { nearIntentsSwapper } from './swappers/NearIntentsSwapper/NearIntentsSwapper.js';
 import { portalsApi } from './swappers/PortalsSwapper/endpoints.js';
 import { portalsSwapper } from './swappers/PortalsSwapper/PortalsSwapper.js';
 import { relaySwapper } from './swappers/RelaySwapper/index.js';
@@ -75,11 +77,16 @@ export const swappers = {
         ...bebopSwapper,
         ...bebopApi,
     },
+    [SwapperName.NearIntents]: {
+        ...nearIntentsSwapper,
+        ...nearIntentsApi,
+    },
     [SwapperName.Test]: undefined,
 };
 // Slippage defaults. Don't export these to ensure the getDefaultSlippageDecimalPercentageForSwapper helper function is used.
 const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002'; // .2%
 const DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
 const DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.025'; // 2.5%
 const DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
 const DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
@@ -112,6 +119,8 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             throw new Error('Default slippage not supported by Relay');
         case SwapperName.ButterSwap:
             return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.NearIntents:
+            return DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE;
         default:
             return assertUnreachable(swapperName);
     }

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const nearIntentsSwapper: Swapper;

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

@@ -0,0 +1,8 @@
+import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+export const nearIntentsSwapper = {
+    executeEvmTransaction,
+    executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/esm/swappers/NearIntentsSwapper/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ONE_CLICK_BASE_URL = "https://1click.chaindefuser.com";
+export declare const DEFAULT_SLIPPAGE_BPS = 50;
+export declare const DEFAULT_QUOTE_DEADLINE_MS: number;

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

@@ -0,0 +1,3 @@
+export const ONE_CLICK_BASE_URL = 'https://1click.chaindefuser.com';
+export const DEFAULT_SLIPPAGE_BPS = 50;
+export const DEFAULT_QUOTE_DEADLINE_MS = 30 * 60 * 1000;

package/dist/esm/swappers/NearIntentsSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const nearIntentsApi: SwapperApi;

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

@@ -0,0 +1,162 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+import { getNearIntentsStatusMessage, mapNearIntentsStatus } from './utils/helpers/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);
+    },
+    checkTradeStatus: async ({ config, swap }) => {
+        const { nearIntentsSpecific } = swap?.metadata ?? {};
+        if (!nearIntentsSpecific?.depositAddress) {
+            return createDefaultStatusResponse(swap?.buyTxHash);
+        }
+        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 txStatus = mapNearIntentsStatus(statusResponse.status);
+            const message = getNearIntentsStatusMessage(statusResponse.status);
+            // Extract buyTxHash from destination chain transactions
+            const buyTxHash = statusResponse.swapDetails?.destinationChainTxHashes?.[0]?.hash;
+            return {
+                status: txStatus,
+                buyTxHash,
+                message,
+            };
+        }
+        catch (error) {
+            return createDefaultStatusResponse(undefined);
+        }
+    },
+};

package/dist/esm/swappers/NearIntentsSwapper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './NearIntentsSwapper.js';
+export * from './endpoints.js';
+export * from './types.js';
+export * from './constants.js';

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

@@ -0,0 +1,4 @@
+export * from './NearIntentsSwapper.js';
+export * from './endpoints.js';
+export * from './types.js';
+export * from './constants.js';

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

@@ -0,0 +1,3 @@
+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>>;

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

@@ -0,0 +1,205 @@
+import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, bnOrZero, 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 { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
+import { QuoteRequest } from '../types.js';
+import { assetToNearIntentsAsset, calculateAccountCreationCosts } from '../utils/helpers/helpers.js';
+import { ApiError, initializeOneClickService, OneClickService } 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);
+        // This shouldn't be the case since we already got a rate and know these exist, but...
+        if (!(originAsset && destinationAsset)) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        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() + DEFAULT_QUOTE_DEADLINE_MS).toISOString(),
+            referral: 'shapeshift',
+            appFees: [
+                {
+                    recipient: DAO_TREASURY_NEAR,
+                    fee: Number(affiliateBps),
+                },
+            ],
+        };
+        const quoteResponse = await OneClickService.getQuote(quoteRequest);
+        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 };
+                }
+                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: quote.depositAddress,
+                    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 ?? '',
+                    },
+                },
+            ],
+        };
+        return Ok([tradeQuote]);
+    }
+    catch (error) {
+        console.error('[NEAR Intents] getTradeQuote error:', error);
+        if (error instanceof ApiError &&
+            (error.body?.message === 'tokenIn is not valid' ||
+                error.body?.message === 'tokenOut is not valid')) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

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

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

@@ -0,0 +1,204 @@
+import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, bnOrZero, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
+import { QuoteRequest } from '../types.js';
+import { assetToNearIntentsAsset, calculateAccountCreationCosts } from '../utils/helpers/helpers.js';
+import { ApiError, initializeOneClickService, OneClickService } from '../utils/oneClickService.js';
+export const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, sendAddress, receiveAddress, } = input;
+    try {
+        initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
+        const originAsset = await assetToNearIntentsAsset(sellAsset);
+        const destinationAsset = await assetToNearIntentsAsset(buyAsset);
+        if (!(originAsset && destinationAsset)) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        // Wallet connected: use actual addresses
+        // No wallet: use "check-price" sentinel with INTENTS types
+        const hasWallet = sendAddress !== undefined;
+        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 ?? 'check-price',
+            refundType: hasWallet
+                ? QuoteRequest.refundType.ORIGIN_CHAIN
+                : QuoteRequest.refundType.INTENTS,
+            recipient: receiveAddress ?? 'check-price',
+            recipientType: hasWallet
+                ? QuoteRequest.recipientType.DESTINATION_CHAIN
+                : QuoteRequest.recipientType.INTENTS,
+            deadline: new Date(Date.now() + DEFAULT_QUOTE_DEADLINE_MS).toISOString(),
+            referral: 'shapeshift',
+            appFees: [
+                {
+                    recipient: DAO_TREASURY_NEAR,
+                    fee: Number(affiliateBps),
+                },
+            ],
+        };
+        const quoteResponse = await OneClickService.getQuote(quoteRequest);
+        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: {
+                    try {
+                        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+                        const data = evm.getErc20Data(depositAddress, sellAmount, contractAddress);
+                        const simulationResult = await simulateWithStateOverrides({
+                            chainId: sellAsset.chainId,
+                            from: getAddress(sendAddress || depositAddress),
+                            to: getAddress(contractAddress ?? depositAddress),
+                            data: (data || '0x'),
+                            value: isNativeEvmAsset(sellAsset.assetId) ? sellAmount : '0',
+                            sellAsset,
+                        }, {
+                            apiKey: deps.config.VITE_TENDERLY_API_KEY,
+                            accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
+                            projectSlug: deps.config.VITE_TENDERLY_PROJECT_SLUG,
+                        });
+                        if (!simulationResult.success) {
+                            return '0';
+                        }
+                        // Calculate network fee using the simulated gas limit
+                        const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                        const { average } = await sellAdapter.getGasFeeData();
+                        const supportsEIP1559 = 'maxFeePerGas' in average;
+                        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+                            ...average,
+                            supportsEIP1559,
+                            gasLimit: simulationResult.gasLimit.toString(),
+                        });
+                        return networkFeeCryptoBaseUnit;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                case CHAIN_NAMESPACE.Utxo: {
+                    const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                    const pubkey = input.xpub;
+                    if (!pubkey) {
+                        return undefined;
+                    }
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: { pubkey },
+                        sendMax: false,
+                    });
+                    return feeData.fast.txFee;
+                }
+                case CHAIN_NAMESPACE.Solana: {
+                    try {
+                        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        const tokenId = isToken(sellAsset.assetId)
+                            ? fromAssetId(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const instructions = await sellAdapter.buildEstimationInstructions({
+                            from: sendAddress,
+                            to: depositAddress,
+                            tokenId,
+                            value: sellAmount,
+                        });
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenId,
+                                instructions,
+                            },
+                            sendMax: false,
+                        });
+                        const txFee = feeData.fast.txFee;
+                        const ataCreationCost = calculateAccountCreationCosts(instructions);
+                        return bn(txFee).plus(ataCreationCost).toString();
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                default:
+                    return undefined;
+            }
+        };
+        const networkFeeCryptoBaseUnit = (await getFeeData()) || '0';
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: quote.amountIn,
+            buyAmountCryptoBaseUnit: quote.amountOut,
+            sellAsset,
+            buyAsset,
+        });
+        const tradeRate = {
+            id: uuid(),
+            receiveAddress: receiveAddress ?? undefined,
+            affiliateBps,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.NearIntents),
+            quoteOrRate: 'rate',
+            swapperName: SwapperName.NearIntents,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    allowanceContract: '',
+                    buyAmountBeforeFeesCryptoBaseUnit: quote.amountOut,
+                    buyAmountAfterFeesCryptoBaseUnit: quote.amountOut,
+                    buyAsset,
+                    feeData: {
+                        protocolFees: {},
+                        networkFeeCryptoBaseUnit,
+                    },
+                    rate,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: quote.amountIn,
+                    sellAsset,
+                    source: SwapperName.NearIntents,
+                    estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+                },
+            ],
+        };
+        return Ok([tradeRate]);
+    }
+    catch (error) {
+        if (error instanceof ApiError &&
+            (error.body?.message === 'tokenIn is not valid' ||
+                error.body?.message === 'tokenOut is not valid')) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents rate',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

package/dist/esm/swappers/NearIntentsSwapper/types.d.ts

@@ -0,0 +1,6 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+export type { QuoteResponse, GetExecutionStatusResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.SolanaMainnet];
+export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
+export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;