@shapeshiftoss/swapper 17.6.9 → 17.6.11

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';
@@ -71,7 +72,27 @@ export const getTradeQuote = async (input, deps) => {
                 },
             ],
         };
-        const quoteResponse = await OneClickService.getQuote(quoteRequest);
+        const maxRetries = 3;
+        let quoteResponse = null;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                quoteResponse = await OneClickService.getQuote(quoteRequest);
+                break;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const isWebSocketError = lastError.message.includes('WebSocket is not ready');
+                if (isWebSocketError && attempt < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                    continue;
+                }
+                throw lastError;
+            }
+        }
+        if (!quoteResponse) {
+            throw lastError ?? new Error('Failed to get quote after retries');
+        }
         const { quote } = quoteResponse;
         if (!quote.depositAddress) {
             throw new Error('Missing deposit address in quote response');
@@ -197,6 +218,21 @@ export const getTradeQuote = async (input, deps) => {
                     });
                     return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
                 }
+                case CHAIN_NAMESPACE.Ton: {
+                    const sellAdapter = deps.assertGetTonChainAdapter(sellAsset.chainId);
+                    const contractAddress = isToken(sellAsset.assetId)
+                        ? fromAssetId(sellAsset.assetId).assetReference
+                        : undefined;
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: {
+                            from,
+                            contractAddress,
+                        },
+                    });
+                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
+                }
                 default:
                     throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
             }
@@ -240,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';
@@ -61,7 +62,27 @@ export const getTradeRate = async (input, deps) => {
                 },
             ],
         };
-        const quoteResponse = await OneClickService.getQuote(quoteRequest);
+        const maxRetries = 3;
+        let quoteResponse = null;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                quoteResponse = await OneClickService.getQuote(quoteRequest);
+                break;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const isWebSocketError = lastError.message.includes('WebSocket is not ready');
+                if (isWebSocketError && attempt < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                    continue;
+                }
+                throw lastError;
+            }
+        }
+        if (!quoteResponse) {
+            throw lastError ?? new Error('Failed to get quote after retries');
+        }
         const { quote } = quoteResponse;
         if (!quote.depositAddress) {
             throw new Error('Missing deposit address in quote response');
@@ -238,6 +259,46 @@ export const getTradeRate = async (input, deps) => {
                         return '0';
                     }
                 }
+                case CHAIN_NAMESPACE.Near: {
+                    try {
+                        const sellAdapter = deps.assertGetNearChainAdapter(sellAsset.chainId);
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: { from: sendAddress },
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                case CHAIN_NAMESPACE.Ton: {
+                    try {
+                        const sellAdapter = deps.assertGetTonChainAdapter(sellAsset.chainId);
+                        const contractAddress = isToken(sellAsset.assetId)
+                            ? fromAssetId(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                contractAddress,
+                            },
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
                 default:
                     return undefined;
             }
@@ -274,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/NearIntentsSwapper/types.d.ts

@@ -1,6 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
 export type { GetExecutionStatusResponse, QuoteResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
-export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet];
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.BitcoinCashMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet, KnownChainIds.PlasmaMainnet, KnownChainIds.TonMainnet];
 export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
 export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

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

@@ -10,6 +10,7 @@ export const nearIntentsSupportedChainIds = [
     KnownChainIds.AvalancheMainnet,
     KnownChainIds.OptimismMainnet,
     KnownChainIds.BitcoinMainnet,
+    KnownChainIds.BitcoinCashMainnet,
     KnownChainIds.DogecoinMainnet,
     KnownChainIds.ZcashMainnet,
     KnownChainIds.SolanaMainnet,
@@ -18,6 +19,8 @@ export const nearIntentsSupportedChainIds = [
     KnownChainIds.StarknetMainnet,
     KnownChainIds.MonadMainnet,
     KnownChainIds.NearMainnet,
+    KnownChainIds.PlasmaMainnet,
+    KnownChainIds.TonMainnet,
 ];
 export const chainIdToNearIntentsChain = {
     [KnownChainIds.EthereumMainnet]: 'eth',
@@ -29,12 +32,15 @@ export const chainIdToNearIntentsChain = {
     [KnownChainIds.AvalancheMainnet]: 'avax',
     [KnownChainIds.OptimismMainnet]: 'op',
     [KnownChainIds.BitcoinMainnet]: 'btc',
+    [KnownChainIds.BitcoinCashMainnet]: 'bch',
     [KnownChainIds.DogecoinMainnet]: 'doge',
     [KnownChainIds.ZcashMainnet]: 'zec',
+    [KnownChainIds.PlasmaMainnet]: 'plasma',
     [KnownChainIds.SolanaMainnet]: 'sol',
     [KnownChainIds.TronMainnet]: 'tron',
     [KnownChainIds.SuiMainnet]: 'sui',
     [KnownChainIds.StarknetMainnet]: 'starknet',
     [KnownChainIds.MonadMainnet]: 'monad',
     [KnownChainIds.NearMainnet]: 'near',
+    [KnownChainIds.TonMainnet]: 'ton',
 };

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

@@ -5,6 +5,25 @@ import { bnOrZero, isToken } from '@shapeshiftoss/utils';
 import { zeroAddress } from 'viem';
 import { chainIdToNearIntentsChain } from '../../types.js';
 import { OneClickService } from '../oneClickService.js';
+const getTokensWithRetry = async () => {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await OneClickService.getTokens();
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            const isWebSocketError = lastError.message.includes('WebSocket is not ready');
+            if (isWebSocketError && attempt < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                continue;
+            }
+            throw lastError;
+        }
+    }
+    throw lastError ?? new Error('Failed to get tokens after retries');
+};
 const ATA_RENT_LAMPORTS = 2040000;
 export const calculateAccountCreationCosts = (instructions) => {
     let totalCost = bnOrZero(0);
@@ -23,8 +42,8 @@ export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
-const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron', 'monad'];
-const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet'];
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron', 'monad', 'plasma'];
+const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet', 'ton'];
 const NEAR_CHAIN = 'near';
 const WNEAR_CONTRACT_ADDRESS = 'wrap.near';
 const isNep245Chain = (chain) => {
@@ -40,7 +59,7 @@ export const assetToNearIntentsAsset = async (asset) => {
     // NEAR chain requires special handling
     // Native NEAR maps to wNEAR (wrap.near)
     if (nearNetwork === NEAR_CHAIN) {
-        const tokens = await OneClickService.getTokens();
+        const tokens = await getTokensWithRetry();
         const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
         const isNativeAsset = assetNamespace === 'slip44';
         // Native NEAR maps to wNEAR, tokens use their contract address directly
@@ -56,7 +75,7 @@ export const assetToNearIntentsAsset = async (asset) => {
     // Asset IDs use hashed format that can't be generated from contract addresses
     const requiresLookup = isNep245Chain(nearNetwork) || isTokenLookupChain(nearNetwork) || asset.chainId === solanaChainId;
     if (requiresLookup) {
-        const tokens = await OneClickService.getTokens();
+        const tokens = await getTokensWithRetry();
         const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
         const isNativeAsset = assetNamespace === 'slip44';
         const contractAddress = !isNativeAsset ? assetReference.toLowerCase() : null;

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/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.js

@@ -14,7 +14,6 @@ import { fetchPortalsTradeEstimate, fetchPortalsTradeOrder } from '../utils/fetc
 import { getPortalsRouterAddressByChainId, isSupportedChainId } from '../utils/helpers.js';
 export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfig) {
     const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, supportsEIP1559, } = input;
-    const adapter = assertGetEvmChainAdapter(chainId);
     const sellAssetChainId = sellAsset.chainId;
     const buyAssetChainId = buyAsset.chainId;
     if (!isSupportedChainId(sellAssetChainId)) {
@@ -31,10 +30,16 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
             details: { chainId: sellAsset.chainId },
         }));
     }
+    if (!isSupportedChainId(chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId },
+        }));
+    }
+    const adapter = assertGetEvmChainAdapter(chainId);
     const isCrossChain = sellAssetChainId !== buyAssetChainId;
     try {
-        if (!isSupportedChainId(chainId))
-            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
         const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
         const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
         if (!sellPortalsNetwork) {

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

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

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.d.ts

@@ -1,2 +1,2 @@
 import type { ChainId } from '@shapeshiftoss/caip';
-export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";
+export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";

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

@@ -1,13 +1,14 @@
-import { btcChainId, fromChainId, monadChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
+import { baseChainId, btcChainId, fromChainId, monadChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
 import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
+import { bnOrZero, chainIdToFeeAssetId, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } 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 axios from 'axios';
 import { getAddress, zeroAddress } from 'viem';
 import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
 import { 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 { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
@@ -136,6 +137,13 @@ export async function getTrade({ input, deps, relayChainMap, }) {
         }));
     }
     const { data: quote } = maybeQuote.unwrap();
+    const orderId = quote.protocol?.v2?.orderId;
+    if (!orderId && sellAsset.chainId === btcChainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Relay quote missing protocol.v2.orderId',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
     const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
     const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
     const rate = getInputOutputRate({
@@ -330,7 +338,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                 value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 chainSpecific: {
                     pubkey: xpub ?? getRelayDefaultUserAddress(sellAsset.chainId),
-                    opReturnData: firstStep.requestId,
+                    opReturnData: orderId,
                 },
                 sendMax: false,
             };
@@ -383,7 +391,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
         // Fallback to Relay's gas amount
         return quote.fees.gas.amount;
     })();
-    const steps = swapSteps.map((quoteStep) => {
+    const steps = await Promise.all(swapSteps.map(async (quoteStep) => {
         const selectedItem = quoteStep.items?.[0];
         if (!selectedItem)
             throw new Error('Relay quote step contains no items');
@@ -393,7 +401,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
             .plus(relayerFeesBuyAssetCryptoBaseUnit)
             .plus(appFeesBaseUnit)
             .toFixed();
-        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = (() => {
+        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = await (async () => {
             if (!selectedItem.data)
                 throw new Error('Relay quote step contains no data');
             if (isRelayQuoteUtxoItemData(selectedItem.data)) {
@@ -405,9 +413,10 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                     relayTransactionMetadata: {
                         from: sendAddress,
                         psbt: selectedItem.data.psbt,
-                        opReturnData: quoteStep.requestId,
+                        opReturnData: orderId,
                         to: relayer,
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                     solanaTransactionMetadata: undefined,
                 };
@@ -425,19 +434,48 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                         gasLimit: selectedItem.data?.gas,
                         chainId: Number(fromChainId(sellAsset.chainId).chainReference),
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                     solanaTransactionMetadata: undefined,
                 };
             }
             if (isRelayQuoteSolanaItemData(selectedItem.data)) {
+                const solanaInstructions = selectedItem.data?.instructions?.map(convertSolanaInstruction);
+                const addressLookupTableAddresses = selectedItem.data?.addressLookupTableAddresses;
+                // Build a trial VersionedTransaction to check if it exceeds the 1232-byte Solana tx size limit
+                const isOversized = await (async () => {
+                    if (!solanaInstructions?.length || !sendAddress)
+                        return false;
+                    try {
+                        const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        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: solanaInstructions,
+                            recentBlockhash: PublicKey.default.toString(),
+                            addressLookupTableAccounts: lookupTableAccounts,
+                        });
+                        const txBytes = new VersionedTransaction(messageV0).serialize();
+                        return txBytes.length > 1232;
+                    }
+                    catch {
+                        return false;
+                    }
+                })();
                 return {
                     allowanceContract: '',
                     solanaTransactionMetadata: {
-                        addressLookupTableAddresses: selectedItem.data?.addressLookupTableAddresses,
-                        instructions: selectedItem.data?.instructions?.map(convertSolanaInstruction),
+                        addressLookupTableAddresses,
+                        instructions: solanaInstructions,
+                        isOversized,
                     },
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                 };
             }
@@ -447,6 +485,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                     solanaTransactionMetadata: undefined,
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
+                        orderId,
                         to: selectedItem.data?.parameter?.contract_address,
                     },
                 };
@@ -477,8 +516,19 @@ export async function getTrade({ input, deps, relayChainMap, }) {
             estimatedExecutionTimeMs: timeEstimate * 1000,
             solanaTransactionMetadata,
             relayTransactionMetadata,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                fixedAssetId: chainIdToFeeAssetId(baseChainId),
+                fixedAsset: deps.assetsById[chainIdToFeeAssetId(baseChainId)],
+                isEstimate: true,
+            }),
         };
-    });
+    }));
     const baseQuoteOrRate = {
         id: quote.steps[0].requestId,
         rate,