@shapeshiftoss/swapper 17.6.10 → 17.6.11

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

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constant_1 = require("../constant");
+const fetchDebridgeSingleChainTrade_1 = require("./fetchDebridgeSingleChainTrade");
+const fetchDebridgeTrade_1 = require("./fetchDebridgeTrade");
+const types_2 = require("./types");
+const getDebridgeAssetAddress = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return constant_1.DEFAULT_DEBRIDGE_TOKEN_ADDRESS;
+    const { assetReference } = (0, caip_1.fromAssetId)(assetId);
+    return (0, caip_1.isAssetReference)(assetReference) ? viem_1.zeroAddress : assetReference;
+};
+async function getTrade({ input, deps, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const isSameChainSwap = sellAsset.chainId === buyAsset.chainId;
+    const sellDebridgeChainId = constant_1.chainIdToDebridgeChainId[sellAsset.chainId];
+    if (sellDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!isSameChainSwap) {
+        const buyDebridgeChainId = constant_1.chainIdToDebridgeChainId[buyAsset.chainId];
+        if (buyDebridgeChainId === undefined) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+        }
+    }
+    const senderAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.sendAddress ?? constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+    })();
+    const recipientAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.receiveAddress)
+                return input.receiveAddress;
+            return constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.receiveAddress;
+    })();
+    const affiliateFeePercent = (() => {
+        if (!(0, utils_1.isTreasuryChainId)(buyAsset.chainId))
+            return undefined;
+        const bps = (0, utils_1.bnOrZero)(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return undefined;
+        return bps.div(100).toFixed();
+    })();
+    const affiliateFeeRecipient = (() => {
+        if (affiliateFeePercent === undefined)
+            return undefined;
+        try {
+            return (0, helpers_1.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 = constant_1.chainIdToDebridgeChainId[buyAsset.chainId];
+    if (buyDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const maybeQuote = await (0, fetchDebridgeTrade_1.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 = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const nativePreFee = (0, utils_1.bnOrZero)(quote.fixFee)
+        .plus((0, utils_1.bnOrZero)(quote.prependedOperatingExpenseCost))
+        .toFixed();
+    const buyAmountBeforeFeesCryptoBaseUnit = buyAmountAfterFeesCryptoBaseUnit;
+    const allowanceContract = (0, chain_adapters_1.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 = constant_1.debridgeChainIdToChainId[sellDebridgeChainId.toString()];
+    const protocolFeeAssetIdForFees = (() => {
+        if (!protocolFeeAssetCaipChainId)
+            return undefined;
+        return (0, utils_1.chainIdToFeeAssetId)(protocolFeeAssetCaipChainId);
+    })();
+    const accountNumber = input.accountNumber;
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: protocolFeeAssetIdForFees && (0, utils_1.bnOrZero)(nativePreFee).gt(0)
+                ? {
+                    [protocolFeeAssetIdForFees]: {
+                        amountCryptoBaseUnit: nativePreFee,
+                        asset: (0, utils_1.getBaseAsset)(sellAsset.chainId),
+                        requiresBalance: true,
+                    },
+                }
+                : {},
+        },
+        source: types_1.SwapperName.Debridge,
+        estimatedExecutionTimeMs: quote.order.approximateFulfillmentDelay * 1000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: quote.orderId,
+        rate,
+        swapperName: types_1.SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Receive address is required for quote',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+}
+exports.getTrade = getTrade;
+function handleDebridgeError(error) {
+    if (!axios_1.default.isAxiosError(error.cause)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Unknown error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const debridgeError = error.cause?.response?.data;
+    if (!(0, types_2.isDebridgeError)(debridgeError)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Unknown error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const errorMessage = debridgeError.errorMessage ?? debridgeError.message ?? 'Unknown error';
+    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+        message: errorMessage,
+        code: types_1.TradeQuoteError.UnknownError,
+    }));
+}
+async function getNetworkFee({ sellAsset, debridgeTransactionMetadata, senderAddress, deps, }) {
+    if (!(0, chain_adapters_1.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 chain_adapters_1.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 chain_adapters_1.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
+        ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toFixed()
+        : '5';
+    const maybeQuote = await (0, fetchDebridgeSingleChainTrade_1.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 = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const protocolFeeAmount = quote.protocolFee ?? '0';
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (protocolFeeAmount === '0')
+            return buyAmountAfterFeesCryptoBaseUnit;
+        return utils_1.BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(utils_1.BigAmount.fromBaseUnit({
+            value: protocolFeeAmount,
+            precision: buyAsset.precision,
+        }))
+            .toBaseUnit();
+    })();
+    const allowanceContract = (0, chain_adapters_1.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 = (0, uuid_1.v4)();
+    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: types_1.SwapperName.Debridge,
+        estimatedExecutionTimeMs: 15_000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: tradeId,
+        rate,
+        swapperName: types_1.SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+            (quote.slippage ? (0, utils_1.bnOrZero)(quote.slippage).div(100).toString() : undefined),
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Receive address is required for quote',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+}

package/dist/cjs/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/cjs/swappers/DebridgeSwapper/utils/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebridgeError = void 0;
+const isDebridgeError = (error) => {
+    return (typeof error === 'object' &&
+        error !== null &&
+        ('errorCode' in error || 'errorId' in error || 'errorMessage' in error));
+};
+exports.isDebridgeError = isDebridgeError;

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

@@ -8,6 +8,7 @@ const web3_js_1 = require("@solana/web3.js");
 const uuid_1 = require("uuid");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const constants_1 = require("../utils/constants");
 const helpers_1 = require("../utils/helpers");
 const getTradeQuote = async (input, deps) => {
@@ -92,6 +93,28 @@ 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 web3_js_1.AddressLookupTableAccount({
+                key: new web3_js_1.PublicKey(info.key),
+                state: web3_js_1.AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+            }));
+            const messageV0 = web3_js_1.MessageV0.compile({
+                payerKey: new web3_js_1.PublicKey(sendAddress),
+                instructions,
+                // Blockhash doesn't affect size, use a dummy one
+                recentBlockhash: web3_js_1.PublicKey.default.toString(),
+                addressLookupTableAccounts: lookupTableAccounts,
+            });
+            const txBytes = new web3_js_1.VersionedTransaction(messageV0).serialize();
+            return txBytes.length > 1232;
+        }
+        catch {
+            return false;
+        }
+    })();
     const getFeeData = async () => {
         const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
         const getFeeDataInput = {
@@ -169,6 +192,7 @@ const getTradeQuote = async (input, deps) => {
                 solanaTransactionMetadata: {
                     addressLookupTableAddresses,
                     instructions,
+                    isOversized,
                 },
                 feeData: {
                     protocolFees,
@@ -182,6 +206,14 @@ 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: (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
+                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
+                }),
             },
         ],
     };

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

@@ -8,6 +8,7 @@ const web3_js_1 = require("@solana/web3.js");
 const uuid_1 = require("uuid");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const constants_1 = require("../utils/constants");
 const helpers_1 = require("../utils/helpers");
 const getTradeRate = async (input, deps) => {
@@ -163,6 +164,14 @@ 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: (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
+                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
+                }),
             },
         ],
     };

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

@@ -10,5 +10,5 @@ const mayaPoolIdAssetIdSymbolMap = generatedTradableAssetMap_json_1.default;
 exports.assetIdToMayaPoolAssetIdMap = (0, invert_1.default)(mayaPoolIdAssetIdSymbolMap);
 const mayaPoolAssetIdToAssetId = (id) => mayaPoolIdAssetIdSymbolMap[id.toUpperCase()];
 exports.mayaPoolAssetIdToAssetId = mayaPoolAssetIdToAssetId;
-const assetIdToMayaPoolAssetId = ({ assetId }) => exports.assetIdToMayaPoolAssetIdMap[assetId.toLowerCase()];
+const assetIdToMayaPoolAssetId = ({ assetId }) => exports.assetIdToMayaPoolAssetIdMap[assetId];
 exports.assetIdToMayaPoolAssetId = assetIdToMayaPoolAssetId;

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

@@ -9,6 +9,7 @@ const uuid_1 = require("uuid");
 const constants_1 = require("../../../constants");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const helpers_1 = require("../../utils/helpers/helpers");
 const constants_2 = require("../constants");
 const types_2 = require("../types");
@@ -278,6 +279,17 @@ const getTradeQuote = async (input, deps) => {
                         timeEstimate: quote.timeEstimate,
                         deadline: quote.deadline ?? '',
                     },
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'fixed_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: quote.amountIn,
+                        buyAmountCryptoBaseUnit: quote.amountOut,
+                        fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId),
+                        fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId)],
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -11,6 +11,7 @@ const constants_1 = require("../../../constants");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
 const tenderly_1 = require("../../../utils/tenderly");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const helpers_1 = require("../../utils/helpers/helpers");
 const constants_2 = require("../constants");
 const types_2 = require("../types");
@@ -337,6 +338,17 @@ const getTradeRate = async (input, deps) => {
                     sellAsset,
                     source: types_1.SwapperName.NearIntents,
                     estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'fixed_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: quote.amountIn,
+                        buyAmountCryptoBaseUnit: quote.amountOut,
+                        fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId),
+                        fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId)],
+                        isEstimate: true,
+                    }),
                 },
             ],
         };