@shapeshiftoss/swapper 17.6.10 → 17.7.0

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

@@ -0,0 +1,367 @@
+"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)(sellAsset.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)(sellAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getTrade] Failed to get treasury address for chainId ${sellAsset.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: 'false',
+        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 fixFee = (0, utils_1.bnOrZero)(quote.fixFee).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)(fixFee).gt(0)
+                ? {
+                    [protocolFeeAssetIdForFees]: {
+                        amountCryptoBaseUnit: fixFee,
+                        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/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,
+                    }),
                 },
             ],
         };

package/dist/cjs/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.js

@@ -9,6 +9,7 @@ const viem_1 = require("viem");
 const __1 = require("../../..");
 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_1 = require("../constants");
 const fetchPortalsTradeOrder_1 = require("../utils/fetchPortalsTradeOrder");
@@ -204,6 +205,15 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
                         steps: portalsTradeOrderResponse.context.steps,
                         route: portalsTradeOrderResponse.context.route,
                     },
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

package/dist/cjs/swappers/RelaySwapper/constant.js

@@ -5,40 +5,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relayErrorCodeToTradeQuoteError = exports.MAXIMUM_SUPPORTED_RELAY_STEPS = exports.DEFAULT_RELAY_TRON_USER_ADDRESS = exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = exports.DEFAULT_RELAY_BTC_USER_ADDRESS = exports.DEFAULT_RELAY_EVM_USER_ADDRESS = exports.RELAY_TRON_TOKEN_ADDRESS = exports.RELAY_SOLANA_TOKEN_ADDRESS = exports.RELAY_BTC_TOKEN_ADDRESS = exports.DEFAULT_RELAY_EVM_TOKEN_ADDRESS = exports.relayChainIdToChainId = exports.RelayStatusMessage = exports.chainIdToRelayChainId = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
-const contracts_1 = require("@shapeshiftoss/contracts");
 const invert_1 = __importDefault(require("lodash/invert"));
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
 const types_1 = require("../../types");
 const types_2 = require("./utils/types");
+// https://docs.relay.link/resources/supported-chains
 exports.chainIdToRelayChainId = {
-    // https://docs.relay.link/resources/supported-chains
     [caip_1.btcChainId]: 8253038,
     [caip_1.ethChainId]: chains_1.mainnet.id,
     [caip_1.arbitrumChainId]: chains_1.arbitrum.id,
     [caip_1.baseChainId]: chains_1.base.id,
     [caip_1.optimismChainId]: chains_1.optimism.id,
     [caip_1.polygonChainId]: chains_1.polygon.id,
-    // https://docs.relay.link/resources/supported-chains
     [caip_1.solanaChainId]: 792703809,
     [caip_1.gnosisChainId]: chains_1.gnosis.id,
     [caip_1.avalancheChainId]: chains_1.avalanche.id,
     [caip_1.bscChainId]: chains_1.bsc.id,
-    // DISABLED: Tron deposits are built as simple TRC20 transfers instead of depositErc20() vault calls,
-    // and the Relay indexer notification is never sent for non-EVM chains. This causes deposits to be
-    // untracked by Relay, resulting in stuck/lost funds. Re-enable once the Tron transaction building
-    // is verified to use the Relay quote calldata (depositErc20) correctly.
-    // [tronChainId]: 728126428,
+    [caip_1.tronChainId]: 728126428,
     [caip_1.monadChainId]: chains_1.monad.id,
     [caip_1.hyperEvmChainId]: chains_1.hyperEvm.id,
     [caip_1.mantleChainId]: chains_1.mantle.id,
     [caip_1.inkChainId]: chains_1.ink.id,
     [caip_1.megaethChainId]: 4326,
     [caip_1.plasmaChainId]: chains_1.plasma.id,
-    [caip_1.plumeChainId]: chains_1.plumeMainnet.id,
     [caip_1.katanaChainId]: chains_1.katana.id,
-    [caip_1.flowEvmChainId]: contracts_1.flowEvmChain.id,
+    [caip_1.etherealChainId]: 5064014,
     [caip_1.celoChainId]: chains_1.celo.id,
+    [caip_1.flowEvmChainId]: chains_1.flowMainnet.id,
+    [caip_1.plumeChainId]: chains_1.plumeMainnet.id,
     [caip_1.storyChainId]: chains_1.story.id,
     [caip_1.zkSyncEraChainId]: chains_1.zksync.id,
     [caip_1.blastChainId]: chains_1.blast.id,
@@ -53,6 +48,8 @@ exports.chainIdToRelayChainId = {
     [caip_1.bobChainId]: chains_1.bob.id,
     [caip_1.modeChainId]: chains_1.mode.id,
     [caip_1.soneiumChainId]: chains_1.soneium.id,
+    [caip_1.seiChainId]: chains_1.sei.id,
+    [caip_1.abstractChainId]: 2741,
 };
 var RelayStatusMessage;
 (function (RelayStatusMessage) {

package/dist/cjs/swappers/RelaySwapper/endpoints.js

@@ -149,7 +149,7 @@ exports.relayApi = {
         }
         if (swap.metadata.relayTransactionMetadata &&
             !txIndexingMap.has(swap.id) &&
-            (0, chain_adapters_1.isEvmChainId)(chainId)) {
+            constant_1.chainIdToRelayChainId[chainId] !== undefined) {
             const relayTxParam = {
                 ...swap.metadata.relayTransactionMetadata,
                 txHash,