@shapeshiftoss/swapper 17.7.2 → 17.8.0

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

@@ -0,0 +1,299 @@
+import { GatewayErrorCode, GatewaySDK, isGatewayError } from '@gobob/bob-sdk';
+import { ASSET_NAMESPACE, ethChainId, fromAssetId, toAssetId } from '@shapeshiftoss/caip';
+import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero, chainIdToFeeAssetId, contractAddressOrUndefined, isToken, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getAddress, zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../../utils.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { BOB_GATEWAY_BASE_URL, BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT, BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE, BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT, bobGatewayChainNameToChainId, chainIdToBobGatewayChainName, decimalSlippageToBobBps, } from './constants.js';
+export const getBobGatewayClient = (config) => {
+    return new GatewaySDK({ basePath: BOB_GATEWAY_BASE_URL, apiKey: config.VITE_BOB_GATEWAY_API_KEY });
+};
+export const assetIdToBobGatewayToken = (assetId) => {
+    // BOB Gateway uses the zero address as the token address for native assets
+    if (!isToken(assetId))
+        return zeroAddress;
+    return fromAssetId(assetId).assetReference;
+};
+export const getBobGatewayAffiliates = (affiliateBps) => {
+    const bps = bnOrZero(affiliateBps);
+    if (!bps.isFinite() || bps.lte(0))
+        return undefined;
+    const affiliateAddress = getTreasuryAddressFromChainId(ethChainId);
+    return [{ address: getAddress(affiliateAddress), bps: bps.toNumber() }];
+};
+export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }) => {
+    const slippage = decimalSlippageToBobBps(slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.BobGateway));
+    try {
+        const quote = await getBobGatewayClient(config).getQuote({
+            fromChain: sellChainName,
+            toChain: buyChainName,
+            fromToken: assetIdToBobGatewayToken(sellAsset.assetId),
+            toToken: assetIdToBobGatewayToken(buyAsset.assetId),
+            fromUserAddress: sender,
+            toUserAddress: recipient,
+            amount,
+            maxSlippage: Number(slippage),
+            affiliates: getBobGatewayAffiliates(affiliateBps),
+        });
+        return Ok(quote);
+    }
+    catch (err) {
+        if (isGatewayError(err)) {
+            switch (err.code) {
+                case GatewayErrorCode.QuoteAmountTooLow:
+                    return Err(createTradeAmountTooSmallErr({
+                        minAmountCryptoBaseUnit: err.details.minimum,
+                        assetId: sellAsset.assetId,
+                    }));
+                case GatewayErrorCode.UnableToCoverFees:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] sell amount does not cover fees',
+                        code: TradeQuoteError.SellAmountBelowTradeFee,
+                        cause: err,
+                    }));
+                case GatewayErrorCode.NoRoute:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] no route found for trade pair',
+                        code: TradeQuoteError.NoRouteFound,
+                        cause: err,
+                    }));
+                case GatewayErrorCode.DisabledChain:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] trading is temporarily halted for this chain',
+                        code: TradeQuoteError.TradingHalted,
+                        cause: err,
+                    }));
+                default:
+                    break;
+            }
+        }
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] failed to fetch quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+export const createBobGatewayOrderMetadata = async (config, gatewayQuote) => {
+    try {
+        const orderResponse = await getBobGatewayClient(config).api.createOrderV2({
+            gatewayQuoteV2: gatewayQuote,
+        });
+        // onramp (BTC→EVM)
+        if ('onramp' in orderResponse) {
+            return Ok({
+                orderId: orderResponse.onramp.orderId,
+                utxoTx: {
+                    depositAddress: orderResponse.onramp.address,
+                    opReturnData: orderResponse.onramp.opReturnData ?? undefined,
+                },
+            });
+        }
+        // offramp (EVM→BTC) and tokenSwap (EVM→EVM) orders share the same tx shape
+        const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+        return Ok({
+            orderId: order.orderId,
+            evmTx: {
+                to: order.tx.to,
+                data: order.tx.data,
+                value: order.tx.value,
+                chain: order.tx.chain,
+            },
+        });
+    }
+    catch (err) {
+        if (isGatewayError(err) && err.code === GatewayErrorCode.InsufficientConfirmedFunds) {
+            return Err(makeSwapErrorRight({
+                message: '[BobGateway] insufficient confirmed balance',
+                code: TradeQuoteError.InsufficientFundsUnconfirmed,
+                cause: err,
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] failed to create order',
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+export const registerBobGatewayTx = async ({ config, orderId, txHash, sellAsset, buyAsset, }) => {
+    const registerTxV2 = (() => {
+        // BTC→EVM
+        if (chainIdToBobGatewayChainName[sellAsset.chainId] === 'bitcoin') {
+            return { onramp: { orderId, bitcoinTxid: txHash } };
+        }
+        // EVM→BTC
+        if (chainIdToBobGatewayChainName[buyAsset.chainId] === 'bitcoin') {
+            return { offramp: { orderId, evmTxhash: txHash } };
+        }
+        // EVM→EVM
+        return { tokenSwap: { orderId, evmTxhash: txHash } };
+    })();
+    await getBobGatewayClient(config).api.registerTxV2({ registerTxV2 });
+};
+export const getBobGatewayQuoteFeeData = async (input, { assertGetUtxoChainAdapter, assertGetEvmChainAdapter }, orderMetadata) => {
+    const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    try {
+        if (orderMetadata.utxoTx && 'xpub' in input) {
+            const { depositAddress, opReturnData } = orderMetadata.utxoTx;
+            const { fast } = await assertGetUtxoChainAdapter(sellAsset.chainId).getFeeData({
+                to: depositAddress,
+                value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                chainSpecific: { pubkey: input.xpub, opReturnData },
+                sendMax: false,
+            });
+            return Ok({
+                networkFeeCryptoBaseUnit: fast.txFee,
+                chainSpecific: { satsPerByte: fast.chainSpecific.satoshiPerByte },
+            });
+        }
+        if (orderMetadata.evmTx && input.sendAddress && 'supportsEIP1559' in input) {
+            const { to, data, value } = orderMetadata.evmTx;
+            const { networkFeeCryptoBaseUnit } = await evm.getFees({
+                adapter: assertGetEvmChainAdapter(sellAsset.chainId),
+                to,
+                data,
+                value,
+                from: input.sendAddress,
+                supportsEIP1559: input.supportsEIP1559,
+            });
+            return Ok({ networkFeeCryptoBaseUnit });
+        }
+        throw new Error('[BobGateway] invalid quote');
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] failed to estimate network fee',
+            code: TradeQuoteError.NetworkFeeEstimationFailed,
+            cause: err,
+        }));
+    }
+};
+export const getBobGatewayRateNetworkFeeCryptoBaseUnit = async (quote, sellAsset, { assertGetEvmChainAdapter, assertGetUtxoChainAdapter }) => {
+    try {
+        if ('onramp' in quote) {
+            const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+            const { fast } = await adapter.httpProvider.getNetworkFees();
+            if (!fast?.satsPerKiloByte)
+                return undefined;
+            const satsPerByte = Math.max(1, Math.ceil(fast.satsPerKiloByte / 1000));
+            return bnOrZero(satsPerByte).times(BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE).toFixed(0);
+        }
+        const defaultGasLimit = 'offramp' in quote
+            ? BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT
+            : BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT;
+        const { average } = await assertGetEvmChainAdapter(sellAsset.chainId).getGasFeeData();
+        const feePerGas = bnOrZero(average.maxFeePerGas).gt(0) ? average.maxFeePerGas : average.gasPrice;
+        return bnOrZero(defaultGasLimit).times(bnOrZero(feePerGas)).toFixed(0);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const mapBobGatewayOrderStatusToTxStatus = (status) => {
+    if ('inProgress' in status)
+        return TxStatus.Pending;
+    if ('success' in status)
+        return TxStatus.Confirmed;
+    if ('failed' in status)
+        return TxStatus.Failed;
+    if ('refunded' in status)
+        return TxStatus.Failed;
+    return TxStatus.Unknown;
+};
+const bobGatewayFeeToAssetId = (fee) => {
+    const chainId = bobGatewayChainNameToChainId[fee.chain];
+    if (!chainId)
+        return;
+    if (fee.address.toLowerCase() === zeroAddress)
+        return chainIdToFeeAssetId(chainId);
+    return toAssetId({
+        chainId,
+        assetNamespace: ASSET_NAMESPACE.erc20,
+        assetReference: fee.address,
+    });
+};
+export const parseBobGatewayQuote = (quote, buyAsset, assetsById) => {
+    const { outputAmount, estimatedTimeInSecs, fees } = (() => {
+        if ('onramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, fees } = quote.onramp;
+            return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+        }
+        if ('offramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, feeBreakdown } = quote.offramp;
+            const { affiliateFee, inclusionFee, protocolFee, solverFee } = feeBreakdown;
+            return {
+                outputAmount,
+                estimatedTimeInSecs,
+                fees: [affiliateFee, inclusionFee, protocolFee, solverFee],
+            };
+        }
+        const { outputAmount, estimatedTimeInSecs, fees } = quote.tokenSwap;
+        return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+    })();
+    const protocolFees = fees.reduce((acc, fee) => {
+        const amountCryptoBaseUnit = bnOrZero(fee.amount);
+        if (amountCryptoBaseUnit.lte(0))
+            return acc;
+        const assetId = bobGatewayFeeToAssetId(fee);
+        if (!assetId)
+            return acc;
+        const asset = assetId === buyAsset.assetId ? buyAsset : assetsById[assetId];
+        if (!asset)
+            return acc;
+        acc[assetId] = {
+            amountCryptoBaseUnit: bnOrZero(acc[assetId]?.amountCryptoBaseUnit)
+                .plus(amountCryptoBaseUnit)
+                .toFixed(),
+            asset,
+            requiresBalance: false,
+        };
+        return acc;
+    }, {});
+    // buyAmountBeforeFees is denominated in the buy asset, so only add back buy-asset-denominated fees
+    const buyAssetFeeCryptoBaseUnit = bnOrZero(protocolFees[buyAsset.assetId]?.amountCryptoBaseUnit);
+    return {
+        buyAmountBeforeFeesCryptoBaseUnit: buyAssetFeeCryptoBaseUnit
+            .plus(bnOrZero(outputAmount.amount))
+            .toFixed(),
+        buyAmountAfterFeesCryptoBaseUnit: outputAmount.amount,
+        protocolFees,
+        estimatedExecutionTimeMs: typeof estimatedTimeInSecs === 'number' ? estimatedTimeInSecs * 1000 : undefined,
+    };
+};
+export const getBobGatewayAllowanceContract = (quote, sellAsset) => {
+    if (!isEvmChainId(sellAsset.chainId))
+        return '';
+    if (!contractAddressOrUndefined(sellAsset.assetId))
+        return '';
+    if ('offramp' in quote)
+        return quote.offramp.txTo;
+    if ('tokenSwap' in quote)
+        return quote.tokenSwap.txTo;
+    return '';
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellChainName = chainIdToBobGatewayChainName[sellAsset.chainId];
+    const buyChainName = chainIdToBobGatewayChainName[buyAsset.chainId];
+    if (!sellChainName) {
+        return Err(makeSwapErrorRight({
+            message: `[BobGateway] unsupported sell chain: ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!buyChainName) {
+        return Err(makeSwapErrorRight({
+            message: `[BobGateway] unsupported buy chain: ${buyAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    return Ok({ sellChainName, buyChainName });
+};

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

@@ -120,7 +120,7 @@ describe('checkTradeStatus same-chain short-circuit', () => {
     it('should proceed to bridge polling for cross-chain swaps', async () => {
         const mockBridgeInfo = {
             id: 12345,
-            state: 1, // Confirmed
+            state: 1,
             toHash: 'dest-tx',
             relayerHash: 'relayer-tx',
             relayerChain: { scanUrl: 'https://scan.url' },
@@ -164,7 +164,7 @@ describe('checkTradeStatus same-chain short-circuit', () => {
             txHash: mockTxHash,
             chainId: mockEvmChainId,
             address: mockAddress,
-            swap: undefined, // No swap data
+            swap: undefined,
             assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
             assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
             fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,

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

@@ -71,7 +71,7 @@ export const getTradeQuote = async (input, _deps) => {
     const buildTxResult = await fetchTxData({
         hash: route.hash,
         slippage,
-        from: sendAddress, // from (source chain address)
+        from: sendAddress,
         receiver: receiveAddress, // receiver (destination chain address)
     });
     if (buildTxResult.isErr())

package/dist/esm/swappers/ButterSwap/test-data/routeQuote.js

@@ -14,12 +14,12 @@ export const ROUTE_QUOTE = {
             },
             tradeType: 0,
             gasFee: {
-                amount: '0.001333043669759539', // human units
+                amount: '0.001333043669759539',
                 symbol: 'ETH',
                 inUSD: '3.0629382849310107',
             },
             swapFee: {
-                nativeFee: '0.0', // human units
+                nativeFee: '0.0',
                 tokenFee: '0.001', // human units
             },
             feeConfig: {
@@ -50,8 +50,8 @@ export const ROUTE_QUOTE = {
                     symbol: 'USDC',
                     icon: 'https://s3.amazonaws.com/map-static-file/mapSwap/ethereum/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/logo.png',
                 },
-                totalAmountIn: '0.999', // in human units
-                totalAmountOut: '2296.409699', // in human units
+                totalAmountIn: '0.999',
+                totalAmountOut: '2296.409699',
                 route: [
                     {
                         amountIn: '0.999',

package/dist/esm/swappers/ButterSwap/utils/butterSwapHistoryService.d.ts

@@ -1,6 +1,6 @@
 import type { AxiosRequestConfig } from 'axios';
 export declare const butterHistoryService: {
-    get: <T = any>(url: string, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
 };

package/dist/esm/swappers/ButterSwap/utils/butterSwapService.d.ts

@@ -1,6 +1,6 @@
 import type { AxiosRequestConfig } from 'axios';
 export declare const butterService: {
-    get: <T = any>(url: string, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
 };

package/dist/esm/swappers/CetusSwapper/utils/constants.d.ts

@@ -1,4 +1,4 @@
 import type { ChainId } from '@shapeshiftoss/caip';
 export declare const SUPPORTED_CETUS_CHAIN_IDS: readonly ChainId[];
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is (typeof SUPPORTED_CETUS_CHAIN_IDS)[number];
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;
 export declare const PYTH_DEPENDENT_PROVIDERS: string[];

package/dist/esm/swappers/ChainflipSwapper/ChainflipSwapper.js

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

package/dist/esm/swappers/ChainflipSwapper/constants.d.ts

@@ -5,7 +5,7 @@ import type { SwapSource } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
 export declare const CHAINFLIP_REGULAR_QUOTE: "regular";
 export declare const CHAINFLIP_DCA_QUOTE: "dca";
-export declare const ChainflipSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.SolanaMainnet];
+export declare const ChainflipSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet];
 export type ChainflipSupportedChainId = (typeof ChainflipSupportedChainIds)[number];
 export declare const ChainflipSupportedAssetIdsByChainId: Partial<Record<KnownChainIds, AssetId[]>>;
 export declare const chainIdToChainflipNetwork: Partial<Record<ChainId, ChainflipNetwork>>;

package/dist/esm/swappers/ChainflipSwapper/constants.js

@@ -1,4 +1,4 @@
-import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, usdtOnArbitrumOneAssetId, usdtOnSolanaAssetId, wbtcAssetId, } from '@shapeshiftoss/caip';
+import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, tronAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, usdtOnArbitrumOneAssetId, usdtOnSolanaAssetId, usdtOnTronAssetId, wbtcAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { SwapperName } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
@@ -9,6 +9,7 @@ export const ChainflipSupportedChainIds = [
     KnownChainIds.ArbitrumMainnet,
     KnownChainIds.BitcoinMainnet,
     KnownChainIds.SolanaMainnet,
+    KnownChainIds.TronMainnet,
 ];
 export const ChainflipSupportedAssetIdsByChainId = {
     [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId, wbtcAssetId],
@@ -19,12 +20,14 @@ export const ChainflipSupportedAssetIdsByChainId = {
     ],
     [KnownChainIds.BitcoinMainnet]: [btcAssetId],
     [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId, usdtOnSolanaAssetId],
+    [KnownChainIds.TronMainnet]: [tronAssetId, usdtOnTronAssetId],
 };
 export const chainIdToChainflipNetwork = {
     [KnownChainIds.EthereumMainnet]: ChainflipNetwork.Ethereum,
     [KnownChainIds.ArbitrumMainnet]: ChainflipNetwork.Arbitrum,
     [KnownChainIds.BitcoinMainnet]: ChainflipNetwork.Bitcoin,
     [KnownChainIds.SolanaMainnet]: ChainflipNetwork.Solana,
+    [KnownChainIds.TronMainnet]: ChainflipNetwork.Tron,
 };
 export const CHAINFLIP_SWAP_SOURCE = SwapperName.Chainflip;
 export const CHAINFLIP_BOOST_SWAP_SOURCE = `${SwapperName.Chainflip} • Boost`;

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

@@ -1,6 +1,7 @@
 import { evm } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
 import { ChainflipStatusMessage } from './constants.js';
@@ -163,6 +164,25 @@ export const chainflipApi = {
         const ratio = simulatedUnits > 0 ? boostedUnits / simulatedUnits : 1;
         return String(Math.ceil(Number(fast.txFee) * ratio));
     },
+    getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+        return adapter.buildSendApiTransaction({
+            to: chainflipSpecific.chainflipDepositAddress,
+            from,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            accountNumber,
+            chainSpecific: { contractAddress: contractAddressOrUndefined(sellAsset.assetId) },
+        });
+    },
+    getTronTransactionFees,
     checkTradeStatus: async ({ config, swap }) => {
         const chainflipSwapId = swap?.metadata.chainflipSwapId;
         if (chainflipSwapId == null)

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

@@ -12,5 +12,6 @@ export declare enum ChainflipNetwork {
     Bitcoin = "Bitcoin",
     Ethereum = "Ethereum",
     Arbitrum = "Arbitrum",
-    Solana = "Solana"
+    Solana = "Solana",
+    Tron = "Tron"
 }

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

@@ -4,4 +4,5 @@ export var ChainflipNetwork;
     ChainflipNetwork["Ethereum"] = "Ethereum";
     ChainflipNetwork["Arbitrum"] = "Arbitrum";
     ChainflipNetwork["Solana"] = "Solana";
+    ChainflipNetwork["Tron"] = "Tron";
 })(ChainflipNetwork || (ChainflipNetwork = {}));

package/dist/esm/swappers/ChainflipSwapper/utils/chainflipService.d.ts

@@ -1,5 +1,5 @@
 export declare const chainflipService: {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
 };

package/dist/esm/swappers/ChainflipSwapper/utils/getQuoteOrRate.js

@@ -1,5 +1,5 @@
 import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
-import { assertUnreachable, BigAmount, bnOrZero } from '@shapeshiftoss/utils';
+import { assertUnreachable, BigAmount, bnOrZero, contractAddressOrUndefined, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
@@ -67,11 +67,14 @@ export const getQuoteOrRate = async (input, deps) => {
     if (maybeQuoteResponse.isErr()) {
         const error = maybeQuoteResponse.unwrapErr();
         const cause = error.cause;
-        if (cause?.message?.includes('code 400') &&
-            cause?.response?.data?.detail?.includes('Amount outside asset bounds')) {
+        // Chainflip returns a 400 with `errors.minimalAmountNative` when the sell amount is below the
+        // route minimum. The `detail` wording varies ("Amount outside asset bounds", "Amount below
+        // minimum. Min: ..."), so key off the field rather than string-matching the message.
+        const minAmountCryptoBaseUnit = cause?.response?.data?.errors?.minimalAmountNative?.[0];
+        if (cause?.response?.status === 400 && minAmountCryptoBaseUnit !== undefined) {
             return Err(createTradeAmountTooSmallErr({
                 assetId: sellAsset.assetId,
-                minAmountCryptoBaseUnit: cause.response?.data?.errors?.minimalAmountNative?.[0],
+                minAmountCryptoBaseUnit,
             }));
         }
         return Err(makeSwapErrorRight({
@@ -119,6 +122,21 @@ export const getQuoteOrRate = async (input, deps) => {
                 const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
                 return { networkFeeCryptoBaseUnit: fast.txFee };
             }
+            case CHAIN_NAMESPACE.Tron: {
+                if (!input.sendAddress)
+                    return { networkFeeCryptoBaseUnit: undefined };
+                const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                const { fast } = await sellAdapter.getFeeData({
+                    // Simulates a self-send, since we don't know the 'to' just yet at this stage
+                    to: input.sendAddress,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    chainSpecific: {
+                        from: input.sendAddress,
+                        contractAddress: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                });
+                return { networkFeeCryptoBaseUnit: fast.txFee };
+            }
             default:
                 throw new Error('Unsupported chainNamespace');
         }
@@ -182,6 +200,8 @@ export const getQuoteOrRate = async (input, deps) => {
                 return 10;
             case CHAIN_NAMESPACE.Solana:
                 return 0;
+            case CHAIN_NAMESPACE.Tron:
+                return 0;
             default:
                 throw new Error('Unsupported chainNamespace');
         }
@@ -228,7 +248,7 @@ export const getQuoteOrRate = async (input, deps) => {
                         buyAsset,
                         sellAsset,
                         accountNumber,
-                        allowanceContract: '0x0', // Chainflip does not use contracts
+                        allowanceContract: '0x0',
                         estimatedExecutionTimeMs: (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.deposit ?? 0) +
                             (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.swap ?? 0) * 1000,
                         chainflipSpecific: {
@@ -286,7 +306,7 @@ export const getQuoteOrRate = async (input, deps) => {
                     buyAsset,
                     sellAsset,
                     accountNumber,
-                    allowanceContract: '0x0', // Chainflip does not use contracts - all Txs are sends
+                    allowanceContract: '0x0',
                     estimatedExecutionTimeMs: ((singleQuoteResponse.estimatedDurationsSeconds?.deposit ?? 0) +
                         (singleQuoteResponse.estimatedDurationsSeconds?.swap ?? 0)) *
                         1000,

package/dist/esm/swappers/ChainflipSwapper/utils/getUtxoTxFees.d.ts

@@ -5,5 +5,5 @@ type GetUtxoTxFeesInput = {
     sellAdapter: UtxoChainAdapter;
     pubKey: string | undefined;
 };
-export declare const getUtxoTxFees: ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }: GetUtxoTxFeesInput) => Promise<Omit<QuoteFeeData, "protocolFees">>;
+export declare const getUtxoTxFees: ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }: GetUtxoTxFeesInput) => Promise<Omit<QuoteFeeData, 'protocolFees'>>;
 export {};

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

@@ -3,7 +3,6 @@ import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
 import type { SwapErrorRight } from '../../../types.js';
-import type { ChainflipSupportedChainId } from '../constants.js';
 import type { ChainflipBaasSwapDepositAddress } from '../models/index.js';
 type ChainFlipBrokerBaseArgs = {
     brokerUrl: string;
@@ -21,8 +20,8 @@ type GetChainFlipSwapArgs = ChainFlipBrokerBaseArgs & {
     numberOfChunks?: number;
     chunkIntervalBlocks?: number;
 };
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainflipSupportedChainId;
-export declare const isSupportedAssetId: (chainId: ChainId, assetId: AssetId) => chainId is ChainflipSupportedChainId;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BitcoinMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet | import("@shapeshiftoss/types").KnownChainIds.TronMainnet;
+export declare const isSupportedAssetId: (chainId: ChainId, assetId: AssetId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BitcoinMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet | import("@shapeshiftoss/types").KnownChainIds.TronMainnet;
 export declare const calculateChainflipMinPrice: ({ sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, sellAsset, buyAsset, }: {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     buyAmountAfterFeesCryptoBaseUnit: string;

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

@@ -45,7 +45,8 @@ export const getChainFlipSwap = ({ brokerUrl, apiKey, sourceAsset, destinationAs
         swapUrl += `&numberOfChunks=${numberOfChunks}`;
         swapUrl += `&chunkIntervalBlocks=${chunkIntervalBlocks}`;
     }
-    return chainflipService.get(swapUrl);
+    // Opening a deposit channel can spike past the default 10s timeout (notably on Tron).
+    return chainflipService.get(swapUrl, { timeout: 30_000 });
 };
 const fetchChainFlipAssets = async ({ brokerUrl, }) => {
     const result = await chainflipService.get(`${brokerUrl}/assets`);

package/dist/esm/swappers/CowSwapper/getCowSwapTradeQuote/getCowSwapTradeQuote.js

@@ -100,7 +100,7 @@ export async function getCowSwapTradeQuote(input, config) {
                 allowanceContract: COW_SWAP_VAULT_RELAYER_ADDRESS,
                 rate,
                 feeData: {
-                    networkFeeCryptoBaseUnit: '0', // no miner fee for CowSwap
+                    networkFeeCryptoBaseUnit: '0',
                     protocolFees: {
                         [sellAsset.assetId]: {
                             amountCryptoBaseUnit: feeAmountInSellTokenCryptoBaseUnit,