@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/esm/swappers/BebopSwapper/utils/fetchFromBebop.js

@@ -3,9 +3,9 @@ import { Err, Ok } from '@sniptt/monads';
 import { getAddress } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
-import { BEBOP_DUMMY_ADDRESS, chainIdToBebopChain } from '../types.js';
+import { BEBOP_DUMMY_ADDRESS, BEBOP_SOLANA_DUMMY_ADDRESS, chainIdToBebopChain } from '../types.js';
 import { bebopServiceFactory } from './bebopService.js';
-import { assetIdToBebopToken } from './helpers/helpers.js';
+import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers/helpers.js';
 export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
         const sellToken = assetIdToBebopToken(sellAsset.assetId);
@@ -86,3 +86,86 @@ export const fetchBebopPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtoc
         apiKey,
     });
 };
+export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
+    try {
+        const sellToken = assetIdToBebopSolanaToken(sellAsset.assetId);
+        const buyToken = assetIdToBebopSolanaToken(buyAsset.assetId);
+        const sellAmountFormatted = bn(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0);
+        const slippagePercentage = bn(slippageTolerancePercentageDecimal ?? 0.003)
+            .times(100)
+            .toNumber();
+        const url = 'https://api.bebop.xyz/pmm/solana/v3/quote';
+        const params = new URLSearchParams({
+            sell_tokens: sellToken,
+            buy_tokens: buyToken,
+            sell_amounts: sellAmountFormatted,
+            taker_address: takerAddress,
+            receiver_address: receiverAddress,
+            slippage: slippagePercentage.toString(),
+            approval_type: 'Standard',
+            skip_validation: 'false',
+            gasless: 'true',
+            source: 'shapeshift',
+        });
+        if (affiliateBps && affiliateBps !== '0') {
+            params.set('fee', affiliateBps);
+        }
+        const bebopService = bebopServiceFactory({ apiKey });
+        const maybeResponse = await bebopService.get(`${url}?${params}`);
+        if (maybeResponse.isErr()) {
+            const err = maybeResponse.unwrapErr();
+            return Err(makeSwapErrorRight({
+                message: 'Failed to fetch quote from Bebop Solana',
+                cause: err.cause,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const response = maybeResponse.unwrap();
+        if (response.data.status !== 'QUOTE_SUCCESS') {
+            return Err(makeSwapErrorRight({
+                message: `Bebop Solana quote not executable: ${response.data.status}`,
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        if (!response.data.solana_tx) {
+            return Err(makeSwapErrorRight({
+                message: 'Missing solana_tx in response',
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        // Reject routes containing ANY AMM/CLMM makers - these produce malformed txs
+        // (wrong signature count in wire format) and require pre-existing ATAs that
+        // Bebop's gasless co-signed flow can't create. This includes mixed routes
+        // like ["raydium clmm-rfqm", "🦊"] where Bebop serializes the tx with fewer
+        // signature slots than the message header requires.
+        // When rejected, other swappers like Jupiter will handle these pairs instead.
+        const hasAmmRoute = response.data.makers.some(maker => maker.toLowerCase().includes('clmm') || maker.toLowerCase().includes('amm'));
+        if (hasAmmRoute) {
+            return Err(makeSwapErrorRight({
+                message: `Bebop Solana quote contains AMM routing (${response.data.makers.join(', ')}), which produces malformed txs`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        return Ok(response.data);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Unexpected error fetching Bebop Solana quote',
+            cause: error,
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};
+export const fetchBebopSolanaPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }) => {
+    const address = receiveAddress || BEBOP_SOLANA_DUMMY_ADDRESS;
+    return fetchBebopSolanaQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress: address,
+        receiverAddress: address,
+        slippageTolerancePercentageDecimal: '0.01',
+        affiliateBps,
+        apiKey,
+    });
+};

package/dist/esm/swappers/BebopSwapper/utils/helpers/helpers.d.ts

@@ -1,11 +1,23 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
+export declare const isSolanaChainId: (chainId: ChainId) => boolean;
 export declare const assetIdToBebopToken: (assetId: AssetId) => string;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet;
+export declare const assetIdToBebopSolanaToken: (assetId: AssetId) => string;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight>;
+}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
+/**
+ * Bebop's /order endpoint has a bug where it hardcodes the taker signature placement
+ * at the last signer index. When the taker's pubkey bytes sort before the maker's,
+ * the taker ends up at an earlier index, and Bebop places the sig in the wrong slot.
+ * This causes ghost txs (order returns "Success" but tx silently fails on-chain).
+ *
+ * Returns true if the taker is at the expected index (safe to execute), false otherwise.
+ * Returns false on decode failure.
+ */
+export declare const isBebopSolanaTxSafe: (solanaTxBase64: string, takerAddress: string) => boolean;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;

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

@@ -1,16 +1,27 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
+import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
 import { bn, convertPrecision, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
+import { PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { getAddress } from 'viem';
 import { TradeQuoteError } from '../../../../types.js';
 import { makeSwapErrorRight } from '../../../../utils.js';
 import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../../types.js';
+export const isSolanaChainId = (chainId) => {
+    return chainId === solanaChainId;
+};
 export const assetIdToBebopToken = (assetId) => {
     if (!isToken(assetId))
         return BEBOP_NATIVE_MARKER;
     const { assetReference } = fromAssetId(assetId);
     return getAddress(assetReference);
 };
+export const assetIdToBebopSolanaToken = (assetId) => {
+    const { assetReference, chainId } = fromAssetId(assetId);
+    if (chainId === solanaChainId && !isToken(assetId)) {
+        return 'So11111111111111111111111111111111111111112';
+    }
+    return assetReference;
+};
 export const isSupportedChainId = (chainId) => {
     return bebopSupportedChainIds.includes(chainId);
 };
@@ -40,6 +51,38 @@ export const assertValidTrade = ({ buyAsset, sellAsset, }) => {
     }
     return Ok(true);
 };
+/**
+ * Bebop's /order endpoint has a bug where it hardcodes the taker signature placement
+ * at the last signer index. When the taker's pubkey bytes sort before the maker's,
+ * the taker ends up at an earlier index, and Bebop places the sig in the wrong slot.
+ * This causes ghost txs (order returns "Success" but tx silently fails on-chain).
+ *
+ * Returns true if the taker is at the expected index (safe to execute), false otherwise.
+ * Returns false on decode failure.
+ */
+export const isBebopSolanaTxSafe = (solanaTxBase64, takerAddress) => {
+    try {
+        const tx = VersionedTransaction.deserialize(Buffer.from(solanaTxBase64, 'base64'));
+        const numSigners = tx.message.header.numRequiredSignatures;
+        if (numSigners < 1) {
+            console.warn('[Bebop Solana] Transaction has no required signers. Rejecting as malformed.');
+            return false;
+        }
+        const signerKeys = tx.message.staticAccountKeys.slice(0, numSigners);
+        const takerPubkey = new PublicKey(takerAddress);
+        const takerIndex = signerKeys.findIndex(key => key.equals(takerPubkey));
+        const expectedIndex = numSigners - 1; // Bebop hardcodes to last signer slot
+        if (takerIndex !== expectedIndex) {
+            console.warn(`[Bebop Solana] Taker signer index ${takerIndex}, expected ${expectedIndex}. Rejecting to avoid ghost tx.`);
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        console.error(`[Bebop Solana] Failed to decode tx for signer check: ${e.message}`);
+        return false;
+    }
+};
 export const calculateRate = ({ buyAmount, sellAmount, buyAsset, sellAsset, }) => {
     return convertPrecision({
         value: buyAmount,

package/dist/esm/swappers/ButterSwap/ButterSwap.js

@@ -1,7 +1,8 @@
-import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
 export const butterSwap = {
     executeEvmTransaction,
     executeSolanaTransaction,
+    executeTronTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -2,6 +2,8 @@ import { evm } from '@shapeshiftoss/chain-adapters';
 import BigNumber from 'bignumber.js';
 import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
 import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
+import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { checkTradeStatus } from './swapperApi/checkTradeStatus.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
@@ -64,6 +66,60 @@ export const butterSwapApi = {
             gasLimit: BigNumber.max(feeData.gasLimit, gasLimit).toFixed(),
         });
     },
+    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, butterSwapTransactionMetadata } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, memo } = butterSwapTransactionMetadata;
+        if (!to)
+            throw new Error('Missing deposit address');
+        if (!memo)
+            throw new Error('Missing memo (opReturnData)');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub, opReturnData: memo },
+            sendMax: false,
+        });
+        return adapter.buildSendApiTransaction({
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            xpub,
+            to,
+            accountNumber,
+            chainSpecific: {
+                accountType,
+                opReturnData: memo,
+                satoshiPerByte: fast.chainSpecific.satoshiPerByte,
+            },
+        });
+    },
+    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { sellAsset, butterSwapTransactionMetadata } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, memo } = butterSwapTransactionMetadata;
+        if (!to)
+            throw new Error('Missing deposit address');
+        if (!memo)
+            throw new Error('Missing memo (opReturnData)');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub, opReturnData: memo },
+            sendMax: false,
+        });
+        return fast.txFee;
+    },
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
+    getTronTransactionFees,
+    getUnsignedTronTransaction,
 };

package/dist/esm/swappers/ButterSwap/swapperApi/checkTradeStatus.js

@@ -1,4 +1,4 @@
-import { solanaChainId } from '@shapeshiftoss/caip';
+import { solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { checkEvmSwapStatus, checkSolanaSwapStatus, createDefaultStatusResponse, } from '../../../utils.js';
@@ -33,6 +33,25 @@ export const checkTradeStatus = async (input) => {
                     fetchIsSmartContractAddressQuery,
                 });
             }
+            if (sellChainId === tronChainId) {
+                const adapter = input.assertGetTronChainAdapter(tronChainId);
+                const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+                if (!tx) {
+                    return createDefaultStatusResponse(txHash);
+                }
+                const contractRet = tx.ret?.[0]?.contractRet;
+                // Only mark as confirmed if SUCCESS AND has confirmations (in a block)
+                const status = contractRet === 'SUCCESS' && tx.confirmations > 0
+                    ? TxStatus.Confirmed
+                    : contractRet === 'REVERT'
+                        ? TxStatus.Failed
+                        : TxStatus.Pending;
+                return {
+                    status,
+                    buyTxHash: txHash,
+                    message: undefined,
+                };
+            }
             // Fallback: unknown same-chain type (should never happen for Butter, but just in case). Avoid bridge polling.
             return createDefaultStatusResponse(txHash);
         }

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

@@ -1,30 +1,26 @@
-import { btcAssetId, btcChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, fromBaseUnit, toBaseUnit, } from '@shapeshiftoss/utils';
+import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
 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 { makeButterSwapAffiliate } from '../utils/constants.js';
 import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, fetchTxData, getButterRoute, isBuildTxSuccess, isRouteSuccess, } from '../xhr.js';
 export const getTradeQuote = async (input, _deps) => {
     const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, sendAddress, slippageTolerancePercentageDecimal, accountNumber, affiliateBps, } = input;
     if (!isEvmChainId(sellAsset.chainId) &&
         sellAsset.chainId !== btcChainId &&
-        sellAsset.chainId !== solanaChainId) {
+        sellAsset.chainId !== solanaChainId &&
+        sellAsset.chainId !== tronChainId) {
         return Err(makeSwapErrorRight({
             message: `Unsupported chain`,
             code: TradeQuoteError.UnsupportedChain,
         }));
     }
-    // Yes, this is supposed to be supported as per checks above, but currently, Butter doesn't yield any quotes for BTC sells
-    if (sellAsset.assetId === btcAssetId) {
-        return Err(makeSwapErrorRight({
-            message: `BTC sells are currently unsupported`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
+    // TODO: Debug why same-chain Tron swaps revert (swapAndCall method works on EVM but 0 successful on Tron)
     if (!sendAddress) {
         return Err(makeSwapErrorRight({
             message: '[getTradeQuote] sendAddress is required for ButterSwap',
@@ -38,7 +34,10 @@ export const getTradeQuote = async (input, _deps) => {
     const routeResult = await getButterRoute({
         sellAsset,
         buyAsset,
-        sellAmountCryptoBaseUnit: fromBaseUnit(sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset.precision),
+        sellAmountCryptoPrecision: BigAmount.fromBaseUnit({
+            value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            precision: sellAsset.precision,
+        }).toPrecision(),
         slippage,
         affiliate: makeButterSwapAffiliate(affiliateBps),
     });
@@ -47,7 +46,10 @@ export const getTradeQuote = async (input, _deps) => {
     const routeResponse = routeResult.unwrap();
     if (!isRouteSuccess(routeResponse)) {
         if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
-            const minAmountCryptoBaseUnit = toBaseUnit(routeResponse.minAmount, sellAsset.precision);
+            const minAmountCryptoBaseUnit = BigAmount.fromPrecision({
+                value: routeResponse.minAmount,
+                precision: sellAsset.precision,
+            }).toBaseUnit();
             return Err(createTradeAmountTooSmallErr({
                 minAmountCryptoBaseUnit,
                 assetId: sellAsset.assetId,
@@ -97,13 +99,19 @@ export const getTradeQuote = async (input, _deps) => {
         }));
     }
     // Map gasFee.amount to networkFeeCryptoBaseUnit using fee asset precision
-    const networkFeeCryptoBaseUnit = toBaseUnit(bnOrZero(route.gasFee?.amount), feeAsset.precision);
+    const networkFeeCryptoBaseUnit = BigAmount.fromPrecision({
+        value: bnOrZero(route.gasFee?.amount),
+        precision: feeAsset.precision,
+    }).toBaseUnit();
     // Use destination receive amount as a priority if present and defined
     // It won't for same-chain swaps, so we fall back to the source chain receive amount (i.e source chain *is* the destination chain)
     const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
     // TODO: affiliate fees not yet here, gut feel is that Butter won't do the swap output - fees logic for us here
     // Sanity check me when affiliates are implemented, and do the math ourselves if needed
-    const buyAmountAfterFeesCryptoBaseUnit = toBaseUnit(outputAmount, buyAsset.precision);
+    const buyAmountAfterFeesCryptoBaseUnit = BigAmount.fromPrecision({
+        value: outputAmount,
+        precision: buyAsset.precision,
+    }).toBaseUnit();
     const rate = getInputOutputRate({
         sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -115,7 +123,12 @@ export const getTradeQuote = async (input, _deps) => {
         if (sellAsset.chainId !== solanaChainId)
             return Ok(undefined);
         const txData = buildTx.data.startsWith('0x') ? buildTx.data.slice(2) : buildTx.data;
-        const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(Buffer.from(txData, 'hex')));
+        const txBytes = Buffer.from(txData, 'hex');
+        // Solana transactions are limited to 1232 bytes. If Butter returns a larger tx,
+        // we need to split it into a Jito bundle (2 txs with tip in the last one).
+        const SOLANA_TX_SIZE_LIMIT = 1232;
+        const isOversized = txBytes.length > SOLANA_TX_SIZE_LIMIT;
+        const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
         const adapter = _deps.assertGetSolanaChainAdapter(sellAsset.chainId);
         try {
             const addressLookupTableAccountKeys = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
@@ -134,6 +147,7 @@ export const getTradeQuote = async (input, _deps) => {
             return Ok({
                 instructions,
                 addressLookupTableAddresses: addressLookupTableAccountKeys,
+                isOversized,
             });
         }
         catch (error) {
@@ -148,7 +162,10 @@ export const getTradeQuote = async (input, _deps) => {
     }
     const solanaTransactionMetadata = maybeSolanaTransactionMetadata?.unwrap();
     const step = {
-        buyAmountBeforeFeesCryptoBaseUnit: toBaseUnit(outputAmount, buyAsset.precision),
+        buyAmountBeforeFeesCryptoBaseUnit: BigAmount.fromPrecision({
+            value: outputAmount,
+            precision: buyAsset.precision,
+        }).toBaseUnit(),
         buyAmountAfterFeesCryptoBaseUnit,
         sellAmountIncludingProtocolFeesCryptoBaseUnit,
         feeData: {
@@ -160,17 +177,29 @@ export const getTradeQuote = async (input, _deps) => {
         buyAsset,
         sellAsset,
         accountNumber,
-        allowanceContract: route.contract ?? '0x0',
+        allowanceContract: sellAsset.chainId === tronChainId ? buildTx.to : route.contract ?? '0x0',
         estimatedExecutionTimeMs: route.timeEstimated * 1000,
         butterSwapTransactionMetadata: {
             to: buildTx.to,
             data: buildTx.data,
             value: buildTx.value,
             gasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
+            method: buildTx.method,
+            args: buildTx.args,
+            memo: buildTx.memo,
         },
         ...(solanaTransactionMetadata && {
             solanaTransactionMetadata,
         }),
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            isEstimate: true,
+        }),
     };
     const tradeQuote = {
         id: route.hash,

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.test.js

@@ -34,6 +34,7 @@ describe('getTradeQuote', () => {
             assertGetSuiChainAdapter: () => vi.fn(),
             assertGetNearChainAdapter: () => vi.fn(),
             assertGetStarknetChainAdapter: () => vi.fn(),
+            assertGetTonChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

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

@@ -1,39 +1,35 @@
-import { btcAssetId, btcChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, toBaseUnit, } from '@shapeshiftoss/utils';
+import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 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 { makeButterSwapAffiliate } from '../utils/constants.js';
 import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, getButterRoute, isRouteSuccess, } from '../xhr.js';
 export const getTradeRate = async (input, _deps) => {
     const { sellAsset, buyAsset, affiliateBps, accountNumber, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
     if (!isEvmChainId(sellAsset.chainId) &&
         sellAsset.chainId !== btcChainId &&
-        sellAsset.chainId !== solanaChainId) {
+        sellAsset.chainId !== solanaChainId &&
+        sellAsset.chainId !== tronChainId) {
         return Err(makeSwapErrorRight({
             message: `Unsupported chain`,
             code: TradeQuoteError.UnsupportedChain,
         }));
     }
-    // Yes, this is supposed to be supported as per checks above, but currently, Butter doesn't yield any quotes for BTC sells
-    if (sellAsset.assetId === btcAssetId) {
-        return Err(makeSwapErrorRight({
-            message: `BTC sells are currently unsupported`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    const amount = bn(sellAmountIncludingProtocolFeesCryptoBaseUnit)
-        .shiftedBy(-sellAsset.precision)
-        .toString();
+    const amount = BigAmount.fromBaseUnit({
+        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
     const feeAssetId = chainIdToFeeAssetId(sellAsset.chainId);
     const slippageTolerancePercentageDecimal = getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ButterSwap);
     const slippage = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toString();
     const result = await getButterRoute({
         sellAsset,
         buyAsset,
-        sellAmountCryptoBaseUnit: amount,
+        sellAmountCryptoPrecision: amount,
         slippage,
         affiliate: makeButterSwapAffiliate(affiliateBps),
     });
@@ -43,7 +39,10 @@ export const getTradeRate = async (input, _deps) => {
     const routeResponse = result.unwrap();
     if (!isRouteSuccess(routeResponse)) {
         if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
-            const minAmountCryptoBaseUnit = toBaseUnit(routeResponse.minAmount, sellAsset.precision);
+            const minAmountCryptoBaseUnit = BigAmount.fromPrecision({
+                value: routeResponse.minAmount,
+                precision: sellAsset.precision,
+            }).toBaseUnit();
             return Err(createTradeAmountTooSmallErr({
                 minAmountCryptoBaseUnit,
                 assetId: sellAsset.assetId,
@@ -66,7 +65,10 @@ export const getTradeRate = async (input, _deps) => {
     const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
     // TODO: affiliate fees not yet here, gut feel is that Butter won't do the swap output - fees logic for us here
     // Sanity check me when affiliates are implemented, and do the math ourselves if needed
-    const buyAmountAfterFeesCryptoBaseUnit = toBaseUnit(outputAmount, buyAsset.precision);
+    const buyAmountAfterFeesCryptoBaseUnit = BigAmount.fromPrecision({
+        value: outputAmount,
+        precision: buyAsset.precision,
+    }).toBaseUnit();
     const rate = getInputOutputRate({
         sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -82,12 +84,18 @@ export const getTradeRate = async (input, _deps) => {
     }
     // Map gasFee.amount to networkFeeCryptoBaseUnit using fee asset precision
     const networkFeeCryptoBaseUnit = bnOrZero(route.gasFee?.amount).gt(0)
-        ? toBaseUnit(route.gasFee.amount, feeAsset.precision)
+        ? BigAmount.fromPrecision({
+            value: route.gasFee.amount,
+            precision: feeAsset.precision,
+        }).toBaseUnit()
         : '0';
     // Always a single step
     const step = {
         rate,
-        buyAmountBeforeFeesCryptoBaseUnit: toBaseUnit(outputAmount, buyAsset.precision),
+        buyAmountBeforeFeesCryptoBaseUnit: BigAmount.fromPrecision({
+            value: outputAmount,
+            precision: buyAsset.precision,
+        }).toBaseUnit(),
         buyAmountAfterFeesCryptoBaseUnit,
         sellAmountIncludingProtocolFeesCryptoBaseUnit,
         feeData: {
@@ -100,6 +108,15 @@ export const getTradeRate = async (input, _deps) => {
         accountNumber,
         allowanceContract: route.contract ?? '0x0',
         estimatedExecutionTimeMs: route.timeEstimated * 1000,
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            isEstimate: true,
+        }),
     };
     const tradeRate = {
         id: route.hash,

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.test.js

@@ -25,6 +25,7 @@ describe('getTradeRate', () => {
             assertGetSuiChainAdapter: () => vi.fn(),
             assertGetNearChainAdapter: () => vi.fn(),
             assertGetStarknetChainAdapter: () => vi.fn(),
+            assertGetTonChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },
@@ -61,6 +62,7 @@ describe('getTradeRate', () => {
             assertGetSuiChainAdapter: () => vi.fn(),
             assertGetNearChainAdapter: () => vi.fn(),
             assertGetStarknetChainAdapter: () => vi.fn(),
+            assertGetTonChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/ButterSwap/types.d.ts

@@ -93,6 +93,7 @@ export type BuildTxSuccessItem = {
         type: string;
         value: unknown;
     }[];
+    memo?: string;
 };
 export type BuildTxResponse = {
     errno: 0;

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

@@ -10,6 +10,7 @@ const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
     43114: KnownChainIds.AvalancheMainnet,
     1360108768460801: KnownChainIds.SolanaMainnet,
     1360095883558913: KnownChainIds.BitcoinMainnet,
+    728126428: KnownChainIds.TronMainnet,
 };
 const CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID = Object.entries(BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID).reduce((acc, [butterSwapChainId, chainId]) => {
     acc[chainId] = Number(butterSwapChainId);

package/dist/esm/swappers/ButterSwap/xhr.d.ts

@@ -20,11 +20,11 @@ type ButterSwapPromise<T> = Promise<Result<T, SwapErrorRight>>;
 export type GetButterRouteArgs = {
     sellAsset: Asset;
     buyAsset: Asset;
-    sellAmountCryptoBaseUnit: string;
+    sellAmountCryptoPrecision: string;
     slippage: string;
     affiliate?: string;
 };
-export declare const getButterRoute: ({ sellAsset, buyAsset, sellAmountCryptoBaseUnit, slippage, affiliate, }: GetButterRouteArgs) => ButterSwapPromise<RouteResponse>;
+export declare const getButterRoute: ({ sellAsset, buyAsset, sellAmountCryptoPrecision, slippage, affiliate, }: GetButterRouteArgs) => ButterSwapPromise<RouteResponse>;
 export type ButterBuildTxArgs = {
     hash: string;
     slippage: string;