@shapeshiftoss/swapper 17.6.10 → 17.7.0

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

@@ -0,0 +1,360 @@
+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(sellAsset.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(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 = 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: '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 = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const fixFee = bnOrZero(quote.fixFee).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(fixFee).gt(0)
+                ? {
+                    [protocolFeeAssetIdForFees]: {
+                        amountCryptoBaseUnit: fixFee,
+                        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/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/swapperApi/getTradeQuote.js

@@ -1,11 +1,12 @@
-import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { CHAIN_NAMESPACE, fromAssetId, nearChainId } from '@shapeshiftoss/caip';
 import { evm } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
+import { bn, bnOrZero, chainIdToFeeAssetId, 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 { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
 import { QuoteRequest } from '../types.js';
@@ -275,6 +276,17 @@ export const getTradeQuote = async (input, deps) => {
                         timeEstimate: quote.timeEstimate,
                         deadline: quote.deadline ?? '',
                     },
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'fixed_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: quote.amountIn,
+                        buyAmountCryptoBaseUnit: quote.amountOut,
+                        fixedAssetId: chainIdToFeeAssetId(nearChainId),
+                        fixedAsset: deps.assetsById[chainIdToFeeAssetId(nearChainId)],
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -1,6 +1,6 @@
-import { CHAIN_NAMESPACE, fromAssetId, monadChainId } from '@shapeshiftoss/caip';
+import { CHAIN_NAMESPACE, fromAssetId, monadChainId, nearChainId } from '@shapeshiftoss/caip';
 import { evm } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
+import { bn, bnOrZero, chainIdToFeeAssetId, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getAddress } from 'viem';
@@ -8,6 +8,7 @@ import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constant
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
 import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
 import { QuoteRequest } from '../types.js';
@@ -334,6 +335,17 @@ export const getTradeRate = async (input, deps) => {
                     sellAsset,
                     source: SwapperName.NearIntents,
                     estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'fixed_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: quote.amountIn,
+                        buyAmountCryptoBaseUnit: quote.amountOut,
+                        fixedAssetId: chainIdToFeeAssetId(nearChainId),
+                        fixedAsset: deps.assetsById[chainIdToFeeAssetId(nearChainId)],
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -6,6 +6,7 @@ import { zeroAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { chainIdToPortalsNetwork } from '../constants.js';
 import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
@@ -201,6 +202,15 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
                         steps: portalsTradeOrderResponse.context.steps,
                         route: portalsTradeOrderResponse.context.route,
                     },
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -1,38 +1,33 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, blastChainId, bobChainId, bscChainId, btcChainId, celoChainId, cronosChainId, ethChainId, flowEvmChainId, gnosisChainId, hemiChainId, hyperEvmChainId, inkChainId, katanaChainId, lineaChainId, mantleChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, plumeChainId, polygonChainId, scrollChainId, solanaChainId, soneiumChainId, sonicChainId, storyChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
-import { flowEvmChain } from '@shapeshiftoss/contracts';
+import { abstractChainId, arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, blastChainId, bobChainId, bscChainId, btcChainId, celoChainId, cronosChainId, ethChainId, etherealChainId, flowEvmChainId, gnosisChainId, hemiChainId, hyperEvmChainId, inkChainId, katanaChainId, lineaChainId, mantleChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, plumeChainId, polygonChainId, scrollChainId, seiChainId, solanaChainId, soneiumChainId, sonicChainId, storyChainId, tronChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, avalanche, base, berachain, blast, bob, bsc, celo, cronos, gnosis, hemi, hyperEvm, ink, katana, linea, mainnet as ethereum, mantle, mode, monad, optimism, plasma, plumeMainnet, polygon, scroll, soneium, sonic, story, unichain, worldchain, zksync, } from 'viem/chains';
+import { arbitrum, avalanche, base, berachain, blast, bob, bsc, celo, cronos, flowMainnet, gnosis, hemi, hyperEvm, ink, katana, linea, mainnet as ethereum, mantle, mode, monad, optimism, plasma, plumeMainnet, polygon, scroll, sei, soneium, sonic, story, unichain, worldchain, zksync, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { RelayErrorCode } from './utils/types.js';
+// https://docs.relay.link/resources/supported-chains
 export const chainIdToRelayChainId = {
-    // https://docs.relay.link/resources/supported-chains
     [btcChainId]: 8253038,
     [ethChainId]: ethereum.id,
     [arbitrumChainId]: arbitrum.id,
     [baseChainId]: base.id,
     [optimismChainId]: optimism.id,
     [polygonChainId]: polygon.id,
-    // https://docs.relay.link/resources/supported-chains
     [solanaChainId]: 792703809,
     [gnosisChainId]: gnosis.id,
     [avalancheChainId]: avalanche.id,
     [bscChainId]: 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,
+    [tronChainId]: 728126428,
     [monadChainId]: monad.id,
     [hyperEvmChainId]: hyperEvm.id,
     [mantleChainId]: mantle.id,
     [inkChainId]: ink.id,
     [megaethChainId]: 4326,
     [plasmaChainId]: plasma.id,
-    [plumeChainId]: plumeMainnet.id,
     [katanaChainId]: katana.id,
-    [flowEvmChainId]: flowEvmChain.id,
+    [etherealChainId]: 5064014,
     [celoChainId]: celo.id,
+    [flowEvmChainId]: flowMainnet.id,
+    [plumeChainId]: plumeMainnet.id,
     [storyChainId]: story.id,
     [zkSyncEraChainId]: zksync.id,
     [blastChainId]: blast.id,
@@ -47,6 +42,8 @@ export const chainIdToRelayChainId = {
     [bobChainId]: bob.id,
     [modeChainId]: mode.id,
     [soneiumChainId]: soneium.id,
+    [seiChainId]: sei.id,
+    [abstractChainId]: 2741,
 };
 export var RelayStatusMessage;
 (function (RelayStatusMessage) {