@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/esm/swappers/DebridgeSwapper/utils/getTrade.js

@@ -0,0 +1,362 @@
+import { fromAssetId, isAssetReference } from '@shapeshiftoss/caip';
+import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { BigAmount, bnOrZero, chainIdToFeeAssetId, getBaseAsset, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { v4 as uuid } from 'uuid';
+import { zeroAddress } from 'viem';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { chainIdToDebridgeChainId, debridgeChainIdToChainId, DEFAULT_DEBRIDGE_TOKEN_ADDRESS, DEFAULT_DEBRIDGE_USER_ADDRESS, } from '../constant.js';
+import { fetchDebridgeSingleChainTrade } from './fetchDebridgeSingleChainTrade.js';
+import { fetchDebridgeTrade } from './fetchDebridgeTrade.js';
+import { isDebridgeError } from './types.js';
+const getDebridgeAssetAddress = (assetId) => {
+    if (isNativeEvmAsset(assetId))
+        return DEFAULT_DEBRIDGE_TOKEN_ADDRESS;
+    const { assetReference } = fromAssetId(assetId);
+    return isAssetReference(assetReference) ? zeroAddress : assetReference;
+};
+export async function getTrade({ input, deps, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const isSameChainSwap = sellAsset.chainId === buyAsset.chainId;
+    const sellDebridgeChainId = chainIdToDebridgeChainId[sellAsset.chainId];
+    if (sellDebridgeChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by deBridge`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!isSameChainSwap) {
+        const buyDebridgeChainId = chainIdToDebridgeChainId[buyAsset.chainId];
+        if (buyDebridgeChainId === undefined) {
+            return Err(makeSwapErrorRight({
+                message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+        }
+    }
+    const senderAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.sendAddress ?? DEFAULT_DEBRIDGE_USER_ADDRESS;
+    })();
+    const recipientAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.receiveAddress)
+                return input.receiveAddress;
+            return DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.receiveAddress;
+    })();
+    const affiliateFeePercent = (() => {
+        if (!isTreasuryChainId(buyAsset.chainId))
+            return undefined;
+        const bps = bnOrZero(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return undefined;
+        return bps.div(100).toFixed();
+    })();
+    const affiliateFeeRecipient = (() => {
+        if (affiliateFeePercent === undefined)
+            return undefined;
+        try {
+            return getTreasuryAddressFromChainId(buyAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getTrade] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
+            return undefined;
+        }
+    })();
+    if (isSameChainSwap) {
+        return getSameChainTrade({
+            input,
+            deps,
+            sellDebridgeChainId,
+            senderAddress,
+            recipientAddress,
+            affiliateFeePercent,
+            affiliateFeeRecipient,
+        });
+    }
+    const buyDebridgeChainId = chainIdToDebridgeChainId[buyAsset.chainId];
+    if (buyDebridgeChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const maybeQuote = await fetchDebridgeTrade({
+        srcChainId: sellDebridgeChainId,
+        srcChainTokenIn: getDebridgeAssetAddress(sellAsset.assetId),
+        srcChainTokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        dstChainId: buyDebridgeChainId,
+        dstChainTokenOut: getDebridgeAssetAddress(buyAsset.assetId),
+        dstChainTokenOutAmount: 'auto',
+        dstChainTokenOutRecipient: recipientAddress,
+        srcChainOrderAuthorityAddress: senderAddress,
+        dstChainOrderAuthorityAddress: recipientAddress,
+        senderAddress,
+        prependOperatingExpenses: 'true',
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        return handleDebridgeError(maybeQuote.unwrapErr());
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.estimation.dstChainTokenOut.recommendedAmount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const nativePreFee = bnOrZero(quote.fixFee)
+        .plus(bnOrZero(quote.prependedOperatingExpenseCost))
+        .toFixed();
+    const buyAmountBeforeFeesCryptoBaseUnit = buyAmountAfterFeesCryptoBaseUnit;
+    const allowanceContract = isEvmChainId(sellAsset.chainId) ? quote.tx.to : '';
+    const debridgeTransactionMetadata = {
+        to: quote.tx.to,
+        data: quote.tx.data,
+        value: quote.tx.value,
+        orderId: quote.orderId,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+    };
+    const networkFeeCryptoBaseUnit = await getNetworkFee({
+        sellAsset,
+        debridgeTransactionMetadata,
+        senderAddress,
+        deps,
+    });
+    const protocolFeeAssetCaipChainId = debridgeChainIdToChainId[sellDebridgeChainId.toString()];
+    const protocolFeeAssetIdForFees = (() => {
+        if (!protocolFeeAssetCaipChainId)
+            return undefined;
+        return chainIdToFeeAssetId(protocolFeeAssetCaipChainId);
+    })();
+    const accountNumber = input.accountNumber;
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: protocolFeeAssetIdForFees && bnOrZero(nativePreFee).gt(0)
+                ? {
+                    [protocolFeeAssetIdForFees]: {
+                        amountCryptoBaseUnit: nativePreFee,
+                        asset: getBaseAsset(sellAsset.chainId),
+                        requiresBalance: true,
+                    },
+                }
+                : {},
+        },
+        source: SwapperName.Debridge,
+        estimatedExecutionTimeMs: quote.order.approximateFulfillmentDelay * 1000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: quote.orderId,
+        rate,
+        swapperName: SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return Err(makeSwapErrorRight({
+                message: 'Receive address is required for quote',
+                code: TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return Ok([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return Ok([tradeRate]);
+}
+function handleDebridgeError(error) {
+    if (!axios.isAxiosError(error.cause)) {
+        return Err(makeSwapErrorRight({
+            message: 'Unknown error',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const debridgeError = error.cause?.response?.data;
+    if (!isDebridgeError(debridgeError)) {
+        return Err(makeSwapErrorRight({
+            message: 'Unknown error',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const errorMessage = debridgeError.errorMessage ?? debridgeError.message ?? 'Unknown error';
+    return Err(makeSwapErrorRight({
+        message: errorMessage,
+        code: TradeQuoteError.UnknownError,
+    }));
+}
+async function getNetworkFee({ sellAsset, debridgeTransactionMetadata, senderAddress, deps, }) {
+    if (!isEvmChainId(sellAsset.chainId))
+        return undefined;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const { average } = await adapter.getGasFeeData();
+    const supportsEIP1559 = 'maxFeePerGas' in average;
+    try {
+        const feeData = await evm.getFees({
+            adapter,
+            data: debridgeTransactionMetadata.data,
+            to: debridgeTransactionMetadata.to,
+            value: debridgeTransactionMetadata.value,
+            from: senderAddress,
+            supportsEIP1559,
+        });
+        return feeData.networkFeeCryptoBaseUnit;
+    }
+    catch {
+        const gasLimitFromApi = debridgeTransactionMetadata.gasLimit;
+        if (!gasLimitFromApi)
+            return undefined;
+        return evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            gasLimit: gasLimitFromApi,
+            supportsEIP1559,
+        });
+    }
+}
+async function getSameChainTrade({ input, deps, sellDebridgeChainId, senderAddress, recipientAddress, affiliateFeePercent, affiliateFeeRecipient, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const slippage = input.slippageTolerancePercentageDecimal
+        ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toFixed()
+        : '5';
+    const maybeQuote = await fetchDebridgeSingleChainTrade({
+        chainId: sellDebridgeChainId,
+        tokenIn: getDebridgeAssetAddress(sellAsset.assetId),
+        tokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        tokenOut: getDebridgeAssetAddress(buyAsset.assetId),
+        tokenOutRecipient: recipientAddress,
+        senderAddress,
+        slippage,
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        return handleDebridgeError(maybeQuote.unwrapErr());
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.tokenOut.amount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const protocolFeeAmount = quote.protocolFee ?? '0';
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (protocolFeeAmount === '0')
+            return buyAmountAfterFeesCryptoBaseUnit;
+        return BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(BigAmount.fromBaseUnit({
+            value: protocolFeeAmount,
+            precision: buyAsset.precision,
+        }))
+            .toBaseUnit();
+    })();
+    const allowanceContract = isEvmChainId(sellAsset.chainId) ? quote.tx.to : '';
+    const debridgeTransactionMetadata = {
+        to: quote.tx.to,
+        data: quote.tx.data,
+        value: quote.tx.value,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+        isSameChainSwap: true,
+    };
+    const networkFeeCryptoBaseUnit = await getNetworkFee({
+        sellAsset,
+        debridgeTransactionMetadata,
+        senderAddress,
+        deps,
+    });
+    const tradeId = uuid();
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber: input.accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: protocolFeeAmount !== '0'
+                ? {
+                    [buyAsset.assetId]: {
+                        amountCryptoBaseUnit: protocolFeeAmount,
+                        asset: {
+                            symbol: quote.tokenOut.symbol,
+                            chainId: buyAsset.chainId,
+                            precision: buyAsset.precision,
+                        },
+                        requiresBalance: false,
+                    },
+                }
+                : {},
+        },
+        source: SwapperName.Debridge,
+        estimatedExecutionTimeMs: 15_000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: tradeId,
+        rate,
+        swapperName: SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+            (quote.slippage ? bnOrZero(quote.slippage).div(100).toString() : undefined),
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return Err(makeSwapErrorRight({
+                message: 'Receive address is required for quote',
+                code: TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return Ok([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return Ok([tradeRate]);
+}

package/dist/esm/swappers/DebridgeSwapper/utils/types.d.ts

@@ -0,0 +1,155 @@
+import type { Asset } from '@shapeshiftoss/types';
+export type DebridgeTradeBaseParams = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+};
+export type DebridgeTradeInputParams<T extends 'rate' | 'quote'> = DebridgeTradeBaseParams & {
+    quoteOrRate: T;
+    receiveAddress: T extends 'rate' ? string | undefined : string;
+    sendAddress: T extends 'rate' ? undefined : string;
+    accountNumber: T extends 'rate' ? undefined : number;
+    slippageTolerancePercentageDecimal?: string;
+};
+export type DebridgeTransactionMetadata = {
+    to: string;
+    data: string;
+    value: string;
+    gasLimit?: string;
+    orderId?: string;
+    isSameChainSwap?: boolean;
+};
+export type DebridgeTokenInfo = {
+    address: string;
+    chainId: number;
+    decimals: number;
+    name: string;
+    symbol: string;
+    amount: string;
+    approximateOperatingExpense?: string;
+    mutatedWithOperatingExpense?: boolean;
+    approximateUsdValue?: number;
+    maxRefundAmount?: string;
+};
+export type DebridgeCostDetail = {
+    type: 'DlnProtocolFee' | 'TakerMargin' | 'EstimatedOperatingExpenses' | 'InputTokenFee' | 'OutputTokenFee';
+    payload: {
+        feeAmount: string;
+        feeBps?: string;
+        chain?: string;
+        tokenAddress?: string;
+    };
+};
+export type DebridgeEstimation = {
+    srcChainTokenIn: DebridgeTokenInfo;
+    srcChainTokenOut?: DebridgeTokenInfo;
+    dstChainTokenOut: DebridgeTokenInfo & {
+        recommendedAmount: string;
+    };
+    costsDetails: DebridgeCostDetail[];
+    recommendedSlippage: number;
+};
+export type DebridgeTx = {
+    to: string;
+    data: string;
+    value: string;
+};
+export type DebridgeOrder = {
+    approximateFulfillmentDelay: number;
+    salt: number;
+    metadata: string;
+};
+export type DebridgeCreateTxResponse = {
+    estimation: DebridgeEstimation;
+    tx: DebridgeTx;
+    orderId: string;
+    order: DebridgeOrder;
+    fixFee: string;
+    prependedOperatingExpenseCost?: string;
+    estimatedTransactionFee?: DebridgeSingleChainEstimatedTransactionFee;
+};
+export type DebridgeOrderStatus = {
+    orderId: string;
+    status: 'None' | 'Created' | 'Fulfilled' | 'SentUnlock' | 'ClaimedUnlock' | 'OrderCancelled' | 'SentOrderCancel' | 'ClaimedOrderCancel';
+};
+export type DebridgeHashObject = {
+    stringValue: string;
+    bytesValue: string;
+    bytesArrayValue: string;
+};
+export type DebridgeOrderDetail = {
+    orderId: DebridgeHashObject;
+    fulfilledDstEventMetadata?: {
+        transactionHash?: DebridgeHashObject;
+    };
+};
+export type DebridgeOrderId = {
+    bytesValue: string;
+    bytesArrayValue: string;
+    stringValue: string;
+};
+export type DebridgeOrderIdsResponse = {
+    orderIds: DebridgeOrderId[];
+};
+export type DebridgeSingleChainTokenInfo = {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    amount: string;
+    approximateUsdValue?: number;
+};
+export type DebridgeSingleChainTokenOut = DebridgeSingleChainTokenInfo & {
+    minAmount: string;
+};
+export type DebridgeSingleChainCostDetail = {
+    chain: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    amountOut: string;
+    type: string;
+    payload: {
+        feeAmount?: string;
+        feeBps?: string;
+        amountOutBeforeCorrection?: string;
+        estimatedVolatilityBps?: string;
+        actualFeeAmount?: string;
+        actualFeeBps?: string;
+        subsidyAmount?: string;
+        feeApproximateUsdValue?: string;
+    };
+};
+export type DebridgeSingleChainEstimatedTransactionFee = {
+    total: string;
+    details: {
+        gasLimit: string;
+        baseFee?: string;
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+    };
+    approximateUsdValue?: number;
+};
+export type DebridgeSingleChainTransactionResponse = {
+    tokenIn: DebridgeSingleChainTokenInfo;
+    tokenOut: DebridgeSingleChainTokenOut;
+    slippage: number;
+    recommendedSlippage: number;
+    protocolFee?: string;
+    costsDetails: DebridgeSingleChainCostDetail[];
+    estimatedTransactionFee?: DebridgeSingleChainEstimatedTransactionFee;
+    tx: {
+        to: string;
+        data: string;
+        value: string;
+    };
+};
+export type DebridgeError = {
+    errorCode?: number;
+    errorId?: string;
+    errorMessage?: string;
+    statusCode?: number;
+    message?: string;
+};
+export declare const isDebridgeError: (error: unknown) => error is DebridgeError;

package/dist/esm/swappers/DebridgeSwapper/utils/types.js

@@ -0,0 +1,5 @@
+export const isDebridgeError = (error) => {
+    return (typeof error === 'object' &&
+        error !== null &&
+        ('errorCode' in error || 'errorId' in error || 'errorMessage' in error));
+};

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

@@ -1,10 +1,11 @@
 import { ASSET_NAMESPACE, CHAIN_NAMESPACE, CHAIN_REFERENCE, fromAssetId, solAssetId, toAssetId, wrappedSolAssetId, } from '@shapeshiftoss/caip';
 import { bn, bnOrZero, convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { PublicKey } from '@solana/web3.js';
+import { AddressLookupTableAccount, MessageV0, PublicKey, VersionedTransaction, } from '@solana/web3.js';
 import { v4 as uuid } from 'uuid';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { COMPUTE_UNIT_MARGIN_MULTIPLIER, TOKEN_2022_PROGRAM_ID } from '../utils/constants.js';
 import { calculateAccountCreationCosts, createSwapInstructions, getJupiterPrice, isSupportedChainId, } from '../utils/helpers.js';
 export const getTradeQuote = async (input, deps) => {
@@ -89,6 +90,28 @@ export const getTradeQuote = async (input, deps) => {
         adapter,
         jupiterUrl,
     });
+    // Build a trial VersionedTransaction to check if it exceeds the 1232-byte Solana tx size limit
+    const isOversized = await (async () => {
+        try {
+            const lookupTableInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+            const lookupTableAccounts = lookupTableInfos.map(info => new AddressLookupTableAccount({
+                key: new PublicKey(info.key),
+                state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+            }));
+            const messageV0 = MessageV0.compile({
+                payerKey: new PublicKey(sendAddress),
+                instructions,
+                // Blockhash doesn't affect size, use a dummy one
+                recentBlockhash: PublicKey.default.toString(),
+                addressLookupTableAccounts: lookupTableAccounts,
+            });
+            const txBytes = new VersionedTransaction(messageV0).serialize();
+            return txBytes.length > 1232;
+        }
+        catch {
+            return false;
+        }
+    })();
     const getFeeData = async () => {
         const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
         const getFeeDataInput = {
@@ -166,6 +189,7 @@ export const getTradeQuote = async (input, deps) => {
                 solanaTransactionMetadata: {
                     addressLookupTableAddresses,
                     instructions,
+                    isOversized,
                 },
                 feeData: {
                     protocolFees,
@@ -179,6 +203,14 @@ export const getTradeQuote = async (input, deps) => {
                 allowanceContract: '0x0',
                 // Swap are so fasts on solana that times are under 100ms displaying 0 or very small amount of time is not user friendly
                 estimatedExecutionTimeMs: undefined,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
+                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
+                }),
             },
         ],
     };

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

@@ -5,6 +5,7 @@ import { PublicKey } from '@solana/web3.js';
 import { v4 as uuid } from 'uuid';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { SOLANA_RANDOM_ADDRESS, TOKEN_2022_PROGRAM_ID } from '../utils/constants.js';
 import { calculateAccountCreationCosts, createSwapInstructions, getJupiterPrice, isSupportedChainId, } from '../utils/helpers.js';
 export const getTradeRate = async (input, deps) => {
@@ -160,6 +161,14 @@ export const getTradeRate = async (input, deps) => {
                 allowanceContract: '0x0',
                 // Swap are so fasts on solana that times are under 100ms displaying 0 or very small amount of time is not user friendly
                 estimatedExecutionTimeMs: undefined,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
+                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
+                }),
             },
         ],
     };

package/dist/esm/swappers/MayachainSwapper/utils/poolAssetHelpers/poolAssetHelpers.js

@@ -3,4 +3,4 @@ import generatedTradableAssetMap from '../../generated/generatedTradableAssetMap
 const mayaPoolIdAssetIdSymbolMap = generatedTradableAssetMap;
 export const assetIdToMayaPoolAssetIdMap = invert(mayaPoolIdAssetIdSymbolMap);
 export const mayaPoolAssetIdToAssetId = (id) => mayaPoolIdAssetIdSymbolMap[id.toUpperCase()];
-export const assetIdToMayaPoolAssetId = ({ assetId }) => assetIdToMayaPoolAssetIdMap[assetId.toLowerCase()];
+export const assetIdToMayaPoolAssetId = ({ assetId }) => assetIdToMayaPoolAssetIdMap[assetId];

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

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTronTransaction, } from '../../utils.js';
+import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils.js';
 export const nearIntentsSwapper = {
     executeEvmTransaction,
     executeSolanaTransaction,
@@ -6,6 +6,7 @@ export const nearIntentsSwapper = {
     executeTronTransaction,
     executeSuiTransaction,
     executeNearTransaction,
+    executeTonTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -245,6 +245,37 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedTonTransaction: ({ stepIndex, tradeQuote, from, assertGetTonChainAdapter, }) => {
+        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 = assertGetTonChainAdapter(sellAsset.chainId);
+        const to = nearIntentsSpecific.depositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+        return adapter.buildSendApiTransaction({
+            to,
+            from,
+            value,
+            accountNumber,
+            chainSpecific: {
+                contractAddress,
+                memo: nearIntentsSpecific.depositMemo,
+            },
+        });
+    },
+    getTonTransactionFees: ({ 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) {