@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,245 @@
+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 { createTradeAmountTooSmallErr, 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);
+        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 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 };
+                }
+                case CHAIN_NAMESPACE.Tron: {
+                    const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                    });
+                    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 };
+                }
+                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) {
+            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,
+        }));
+    }
+};

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,260 @@
+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 { createTradeAmountTooSmallErr, 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) {
+            console.log('[NEAR] Returning error - originAsset not supported');
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        if (!destinationAsset) {
+            console.log('[NEAR] Returning error - destinationAsset not supported');
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        // 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';
+                    }
+                }
+                case CHAIN_NAMESPACE.Tron: {
+                    try {
+                        const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                case CHAIN_NAMESPACE.Sui: {
+                    try {
+                        const sellAdapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+                        const tokenId = isToken(sellAsset.assetId)
+                            ? fromAssetId(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenId,
+                            },
+                            sendMax: false,
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    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) {
+            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 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 { GetExecutionStatusResponse, QuoteResponse, 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, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet];
+export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
+export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

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

@@ -0,0 +1,32 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+export const nearIntentsSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BaseMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.BitcoinMainnet,
+    KnownChainIds.DogecoinMainnet,
+    KnownChainIds.SolanaMainnet,
+    KnownChainIds.TronMainnet,
+    KnownChainIds.SuiMainnet,
+];
+export const chainIdToNearIntentsChain = {
+    [KnownChainIds.EthereumMainnet]: 'eth',
+    [KnownChainIds.ArbitrumMainnet]: 'arb',
+    [KnownChainIds.BaseMainnet]: 'base',
+    [KnownChainIds.GnosisMainnet]: 'gnosis',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.PolygonMainnet]: 'pol',
+    [KnownChainIds.AvalancheMainnet]: 'avax',
+    [KnownChainIds.OptimismMainnet]: 'op',
+    [KnownChainIds.BitcoinMainnet]: 'btc',
+    [KnownChainIds.DogecoinMainnet]: 'doge',
+    [KnownChainIds.SolanaMainnet]: 'sol',
+    [KnownChainIds.TronMainnet]: 'tron',
+    [KnownChainIds.SuiMainnet]: 'sui',
+};

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

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { GetExecutionStatusResponse } from '../../types.js';
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;
+export declare const getNearIntentsAsset: ({ nearNetwork, contractAddress, }: {
+    nearNetwork: string;
+    contractAddress: string;
+}) => string;
+export declare const assetToNearIntentsAsset: (asset: Asset) => Promise<string | null>;
+export declare const mapNearIntentsStatus: (status: GetExecutionStatusResponse['status']) => TxStatus;
+export declare const getNearIntentsStatusMessage: (status: GetExecutionStatusResponse['status']) => string | undefined;

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

@@ -0,0 +1,96 @@
+import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
+import { fromAssetId, solanaChainId, suiChainId } from '@shapeshiftoss/caip';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero, isToken } from '@shapeshiftoss/utils';
+import { zeroAddress } from 'viem';
+import { chainIdToNearIntentsChain } from '../../types.js';
+import { OneClickService } from '../oneClickService.js';
+const ATA_RENT_LAMPORTS = 2040000;
+export const calculateAccountCreationCosts = (instructions) => {
+    let totalCost = bnOrZero(0);
+    for (const ix of instructions) {
+        if (ix.programId.toString() === ASSOCIATED_PROGRAM_ID.toString()) {
+            totalCost = totalCost.plus(ATA_RENT_LAMPORTS);
+        }
+    }
+    return totalCost.toString();
+};
+export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
+    // Native EVM assets: "nep141:eth.omft.near"
+    if (contractAddress === zeroAddress) {
+        return `nep141:${nearNetwork}.omft.near`;
+    }
+    // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
+    return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
+};
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron'];
+const TOKEN_LOOKUP_CHAINS = ['sui'];
+export const assetToNearIntentsAsset = async (asset) => {
+    const nearNetwork = chainIdToNearIntentsChain[asset.chainId];
+    if (!nearNetwork)
+        return null;
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, SUI) and Solana require token lookup
+    // Asset IDs use hashed format that can't be generated from contract addresses
+    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) ||
+        TOKEN_LOOKUP_CHAINS.includes(nearNetwork) ||
+        asset.chainId === solanaChainId ||
+        asset.chainId === suiChainId;
+    if (requiresLookup) {
+        const tokens = await OneClickService.getTokens();
+        const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
+        const isNativeAsset = assetNamespace === 'slip44';
+        const contractAddress = !isNativeAsset ? assetReference.toLowerCase() : null;
+        const match = tokens.find((t) => {
+            if (t.blockchain !== nearNetwork)
+                return false;
+            return contractAddress
+                ? t.contractAddress?.toLowerCase() === contractAddress
+                : !t.contractAddress;
+        });
+        if (!match) {
+            return null;
+        }
+        return match.assetId;
+    }
+    // NEP-141 chains (ETH, ARB, BASE, GNOSIS, BTC, DOGE): use predictable format
+    const contractAddress = isToken(asset.assetId)
+        ? fromAssetId(asset.assetId).assetReference
+        : zeroAddress;
+    return getNearIntentsAsset({ nearNetwork, contractAddress });
+};
+export const mapNearIntentsStatus = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+        case 'KNOWN_DEPOSIT_TX':
+        case 'PROCESSING':
+            return TxStatus.Pending;
+        case 'SUCCESS':
+            return TxStatus.Confirmed;
+        case 'INCOMPLETE_DEPOSIT':
+        case 'REFUNDED':
+        case 'FAILED':
+            return TxStatus.Failed;
+        default:
+            return TxStatus.Unknown;
+    }
+};
+export const getNearIntentsStatusMessage = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+            return 'Waiting for deposit...';
+        case 'KNOWN_DEPOSIT_TX':
+            return 'Deposit detected, waiting for confirmation...';
+        case 'PROCESSING':
+            return 'Processing swap...';
+        case 'SUCCESS':
+            return undefined;
+        case 'INCOMPLETE_DEPOSIT':
+            return 'Insufficient deposit amount';
+        case 'REFUNDED':
+            return 'Swap failed, funds refunded';
+        case 'FAILED':
+            return 'Swap failed';
+        default:
+            return 'Unknown status';
+    }
+};

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

@@ -0,0 +1,3 @@
+import { ApiError, OneClickService } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const initializeOneClickService: (apiKey: string) => void;
+export { ApiError, OneClickService };