@shapeshiftoss/swapper 20.1.1 → 20.3.0

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

@@ -2,7 +2,6 @@ import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/ev
 import { getSolanaTransactionFees } from '../../utils/solana/getSolanaTransactionFees.js';
 import { getUnsignedSolanaTransaction } from '../../utils/solana/getUnsignedSolanaTransaction.js';
 import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
-import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { checkTradeStatus } from './swapperApi/checkTradeStatus.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
@@ -12,8 +11,6 @@ export const butterSwapApi = {
     checkTradeStatus,
     getEvmTransactionFees,
     getUnsignedEvmTransaction,
-    getUnsignedUtxoTransaction,
-    getUtxoTransactionFees,
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
     getTronTransactionFees,

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

@@ -56,7 +56,7 @@ export const getTradeQuote = async (input, deps) => {
     });
     if (maybeStepData.isErr())
         return Err(maybeStepData.unwrapErr());
-    const { networkFeeCryptoBaseUnit, transactionData, butterSwapTransactionMetadata } = maybeStepData.unwrap();
+    const { networkFeeCryptoBaseUnit, transactionData } = maybeStepData.unwrap();
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
@@ -66,10 +66,9 @@ export const getTradeQuote = async (input, deps) => {
             {
                 ...stepCommon,
                 accountNumber,
-                // Tron exec still builds from legacy metadata whose spender is the buildTx target
+                // Tron routes pull the sell token from the buildTx target
                 allowanceContract: sellAsset.chainId === tronChainId ? buildTx.to : stepCommon.allowanceContract,
                 transactionData,
-                butterSwapTransactionMetadata,
                 feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
         ],

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

@@ -2,8 +2,7 @@ import { KnownChainIds } from '@shapeshiftoss/types';
 import { bn } from '@shapeshiftoss/utils';
 import { Ok } from '@sniptt/monads';
 import { describe, expect, it, vi } from 'vitest';
-import { BTC, ETH, USDC_MAINNET, WETH } from '../../../utils/test-data/assets.js';
-import ethBtcRoute from '../test-data/eth-btc.json';
+import { ETH, USDC_MAINNET, WETH } from '../../../utils/test-data/assets.js';
 import { ROUTE_QUOTE } from '../test-data/routeQuote.js';
 import { butterService } from '../utils/butterSwapService.js';
 import { getTradeRate } from './getTradeRate.js';
@@ -59,51 +58,4 @@ describe('getTradeRate', () => {
         const tradeRate = result.unwrap();
         expect(tradeRate[0].rate).toBe('2296.409699');
     });
-    it('should return a correct trade rate and steps for a multi-hop ETH->BTC route', async () => {
-        const deps = {
-            assetsById: { [ETH.assetId]: ETH, [BTC.assetId]: BTC },
-            assertGetChainAdapter: () => vi.fn(),
-            assertGetEvmChainAdapter: () => mockEvmChainAdapter,
-            assertGetUtxoChainAdapter: () => vi.fn(),
-            assertGetCosmosSdkChainAdapter: () => vi.fn(),
-            assertGetSolanaChainAdapter: () => vi.fn(),
-            assertGetTronChainAdapter: () => vi.fn(),
-            assertGetSuiChainAdapter: () => vi.fn(),
-            assertGetNearChainAdapter: () => vi.fn(),
-            assertGetStarknetChainAdapter: () => vi.fn(),
-            assertGetTonChainAdapter: () => vi.fn(),
-            config: {
-                VITE_BUTTERSWAP_CLIENT_ID: 'test',
-            },
-            mixPanel: undefined,
-            fetchIsSmartContractAddressQuery: vi.fn(),
-        };
-        const input = {
-            sellAsset: ETH,
-            buyAsset: BTC,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit: bn(1).shiftedBy(18).toString(),
-            affiliateBps: '0',
-            allowMultiHop: true,
-            receiveAddress: '0x123',
-            accountNumber: undefined,
-            quoteOrRate: 'rate',
-            chainId: KnownChainIds.EthereumMainnet,
-            supportsEIP1559: false,
-        };
-        // Use the first route in the eth-btc.json data
-        vi.mocked(butterService.get).mockResolvedValue(Ok({ data: ethBtcRoute }));
-        const result = await getTradeRate(input, deps);
-        expect(result.isOk()).toBe(true);
-        const tradeRate = result.unwrap()[0];
-        expect(tradeRate).toBeDefined();
-        // The expected rate is dstChain.totalAmountOut / srcChain.totalAmountIn
-        expect(tradeRate.rate).toBe('0.02284418');
-        // Should have a single step
-        expect(tradeRate.steps).toBeDefined();
-        expect(tradeRate.steps.length).toBe(1);
-        // The step should have the correct rate
-        expect(tradeRate.steps[0]?.rate).toBe('0.02284418');
-        // The buyAmountAfterFeesCryptoBaseUnit of the step should match the output in base units
-        expect(tradeRate.steps[0]?.buyAmountAfterFeesCryptoBaseUnit).toBe('2284418'); // 0.02284418 BTC in base units
-    });
 });

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

@@ -1,18 +1,7 @@
 import type { Hex } from 'viem';
-import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput } from '../../types.js';
-export type ButterSwapTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput;
-export type ButterSwapTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
-export type ButterSwapTransactionMetadata = {
-    to: string;
-    data: string;
-    value: Hex;
-    method?: string;
-    args?: {
-        type: string;
-        value: unknown;
-    }[];
-    memo?: string;
-};
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput } from '../../types.js';
+export type ButterSwapTradeQuoteInput = GetEvmTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput;
+export type ButterSwapTradeRateInput = GetEvmTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
 export type ErrorType = {
     errno: number;
     message: string;

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

@@ -1 +1,3 @@
+export declare const BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY = "1000000";
+export declare const BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES = 2400;
 export declare const makeButterSwapAffiliate: (affiliateBps: string) => string | undefined;

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

@@ -1,5 +1,8 @@
 import { bnOrZero } from '@shapeshiftoss/utils';
 const BUTTERSWAP_AFFILIATE = 'shapeshift';
+// The router's total energy per swap, before its deployer's share comes off
+export const BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY = '1000000';
+export const BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES = 2400;
 // Format is `<nickname>[:rate]`, where rate is in basis points (e.g. `shapeshift:60` = 0.6%).
 export const makeButterSwapAffiliate = (affiliateBps) => {
     if (bnOrZero(affiliateBps).lte(0))

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

@@ -2,7 +2,7 @@ import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
 import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
-import type { BuildTxSuccessItem, ButterSwapTransactionMetadata, RouteSuccessItem } from '../types.js';
+import type { BuildTxSuccessItem, RouteSuccessItem } from '../types.js';
 export declare const BUTTERSWAP_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
 type BaseArgs = {
     route: RouteSuccessItem;
@@ -19,8 +19,7 @@ type ButterSwapRateStepData = {
     networkFeeCryptoBaseUnit: string;
 };
 type ButterSwapQuoteStepData = {
-    transactionData?: TxBuildData;
-    butterSwapTransactionMetadata?: ButterSwapTransactionMetadata;
+    transactionData: TxBuildData;
     networkFeeCryptoBaseUnit: string;
 };
 export declare function getButterSwapStepData(args: Extract<GetButterSwapStepDataArgs, {

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

@@ -7,7 +7,8 @@ import { TradeQuoteError } from '../../../types.js';
 import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit, omitComputeBudgetInstructions, withComputeUnitLimit, } from '../../../utils/solana/index.js';
-import { getUtxoNetworkFeeCryptoBaseUnit, UTXO_PLACEHOLDER_ADDRESS } from '../../../utils/utxo/index.js';
+import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/index.js';
+import { BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES, BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY, } from './constants.js';
 import { getProviderNetworkFeeCryptoBaseUnit } from './helpers.js';
 // Jupiter swap legs can consume more units than simulated when pool state moves between
 // simulation and landing (CLMM tick crossings), 1.4 matches Jupiter's dynamicComputeUnitLimit margin
@@ -66,56 +67,6 @@ export async function getButterSwapStepData(args) {
                 return Err(makeNetworkFeeEstimationFailedErr('getButterSwapStepData', error));
             }
         }
-        case CHAIN_NAMESPACE.Utxo: {
-            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
-            const pubkey = 'xpub' in input ? input.xpub : undefined;
-            if (args.type === 'rate') {
-                const networkFeeCryptoBaseUnit = await (async () => {
-                    try {
-                        const { networkFeeCryptoBaseUnit } = await getUtxoNetworkFeeCryptoBaseUnit({
-                            adapter,
-                            pubkey,
-                            to: input.sendAddress ?? UTXO_PLACEHOLDER_ADDRESS,
-                            value: sellAmountCryptoBaseUnit,
-                        });
-                        return networkFeeCryptoBaseUnit;
-                    }
-                    catch {
-                        return getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
-                    }
-                })();
-                const stepData = { networkFeeCryptoBaseUnit };
-                return Ok(stepData);
-            }
-            const { buildTx } = args;
-            // opReturnData routes the bridge for BTC deposits
-            if (!buildTx.memo) {
-                return Err(makeSwapErrorRight({
-                    message: '[getButterSwapStepData] Missing memo (opReturnData)',
-                    code: TradeQuoteError.InvalidResponse,
-                }));
-            }
-            const transactionData = {
-                type: 'utxo',
-                to: buildTx.to,
-                opReturnData: buildTx.memo,
-                value: sellAmountCryptoBaseUnit,
-            };
-            try {
-                const { networkFeeCryptoBaseUnit } = await getUtxoNetworkFeeCryptoBaseUnit({
-                    adapter,
-                    pubkey,
-                    to: transactionData.to,
-                    value: transactionData.value,
-                    opReturnData: transactionData.opReturnData,
-                });
-                const stepData = { transactionData, networkFeeCryptoBaseUnit };
-                return Ok(stepData);
-            }
-            catch (error) {
-                return Err(makeNetworkFeeEstimationFailedErr('getButterSwapStepData', error));
-            }
-        }
         case CHAIN_NAMESPACE.Solana: {
             const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
             if (args.type === 'rate') {
@@ -165,26 +116,52 @@ export async function getButterSwapStepData(args) {
                 return Err(makeTradeStepBuildFailedErr('getButterSwapStepData', error));
             }
         }
-        // Not yet migrated to a TxBuildData variant - exec still builds from legacy metadata
         case CHAIN_NAMESPACE.Tron: {
-            const networkFeeCryptoBaseUnit = getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
+            const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
             if (args.type === 'rate') {
+                // Butter's gasFee is a fraction of what the router burns, so rates price the measured swap at the router's share
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    if (!route.contract)
+                        return getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
+                    try {
+                        return await getTronContractCallFallbackFeeCryptoBaseUnit({
+                            adapter,
+                            energy: BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY,
+                            bandwidthBytes: BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES,
+                            contractAddress: route.contract,
+                        });
+                    }
+                    catch {
+                        return getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
+                    }
+                })();
                 const stepData = { networkFeeCryptoBaseUnit };
                 return Ok(stepData);
             }
-            const { buildTx } = args;
-            const stepData = {
-                butterSwapTransactionMetadata: {
-                    to: buildTx.to,
-                    data: buildTx.data,
-                    value: buildTx.value,
-                    method: buildTx.method,
-                    args: buildTx.args,
-                    memo: buildTx.memo,
-                },
-                networkFeeCryptoBaseUnit,
+            const { buildTx, from } = args;
+            const call = {
+                to: buildTx.to,
+                data: buildTx.data,
+                value: fromHex(buildTx.value, 'bigint').toString(),
             };
-            return Ok(stepData);
+            try {
+                const stepData = {
+                    transactionData: { type: 'tron', ...call },
+                    networkFeeCryptoBaseUnit: await getTronContractCallNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        transactionData: call,
+                        from,
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress: buildTx.to,
+                        fallbackEnergy: BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY,
+                    }),
+                };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getButterSwapStepData', error));
+            }
         }
         default:
             return Err(makeSwapErrorRight({

package/dist/esm/swappers/ButterSwap/utils/getButterSwapStepData.test.js

@@ -1,7 +1,7 @@
 import { solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { describe, expect, it, vi } from 'vitest';
 import { TradeQuoteError } from '../../../types.js';
-import { BTC, ETH, RUNE, WETH } from '../../../utils/test-data/assets.js';
+import { ETH, RUNE, WETH } from '../../../utils/test-data/assets.js';
 import { ROUTE_QUOTE } from '../test-data/routeQuote.js';
 import { getButterSwapStepData } from './getButterSwapStepData.js';
 // The override path reads live chain state - resolve to no override so estimation exercises the
@@ -15,6 +15,11 @@ const route = ROUTE_QUOTE.data[0];
 const PROVIDER_GAS_FEE_BASE_UNIT = '1333043669759539'; // 0.001333043669759539 ETH
 const SOL = { ...ETH, assetId: `${solanaChainId}/slip44:501`, chainId: solanaChainId };
 const TRX = { ...ETH, assetId: `${tronChainId}/slip44:195`, chainId: tronChainId };
+const USDT_TRON = {
+    ...ETH,
+    assetId: `${tronChainId}/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t`,
+    chainId: tronChainId,
+};
 const evmBuildTx = {
     to: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
     data: '0xdeadbeef',
@@ -25,6 +30,7 @@ const makeDeps = (adapters) => ({
     assertGetEvmChainAdapter: () => adapters.evm,
     assertGetUtxoChainAdapter: () => adapters.utxo,
     assertGetSolanaChainAdapter: () => adapters.solana,
+    assertGetTronChainAdapter: () => adapters.tron,
 });
 const evmAdapter = ({ gasPrice = '1000000000', estimatedGasLimit = '500000', throwOnGasFeeData = false, throwOnFeeData = false, } = {}) => ({
     getGasFeeData: () => {
@@ -134,116 +140,152 @@ describe('getButterSwapStepData', () => {
             expect(actual.unwrapErr().code).toBe(TradeQuoteError.NetworkFeeEstimationFailed);
         });
     });
-    describe('utxo', () => {
-        const utxoAdapter = {
-            getFeeData: () => Promise.resolve({ fast: { txFee: '4200' } }),
-            httpProvider: {
-                getNetworkFees: () => Promise.resolve({ fast: { satsPerKiloByte: 10000 } }),
-            },
-        };
-        it('estimates off the default vsize for a rate with no pubkey', async () => {
+    describe('solana', () => {
+        it('uses the provider fee for a rate, since swap instructions do not exist yet', async () => {
+            const assertGetSolanaChainAdapter = vi.fn();
             const actual = await getButterSwapStepData({
                 type: 'rate',
                 input: {},
-                deps: makeDeps({ utxo: utxoAdapter }),
+                deps: { assertGetSolanaChainAdapter },
                 route,
-                sellAsset: BTC,
-                feeAsset: BTC,
-                sellAmountCryptoBaseUnit: '100000',
+                sellAsset: SOL,
+                feeAsset: SOL,
+                sellAmountCryptoBaseUnit: '1000000000',
                 spenderAddress: '',
             });
-            // 10 sats/byte * 200 vbyte default
-            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '2000' });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+    });
+    describe('tron', () => {
+        const tronBuildTx = { ...evmBuildTx, to: 'TRouterAddress' };
+        const tronAdapter = ({ txFee = '9000000', allowance = '0' } = {}) => ({
+            getFeeData: vi.fn().mockResolvedValue({ fast: { txFee } }),
+            httpProvider: {
+                getChainPrices: () => Promise.resolve({ energyPrice: 100, bandwidthPrice: 1000 }),
+                getTrc20Allowance: vi.fn().mockResolvedValue(allowance),
+                getTrc20Balance: vi.fn().mockResolvedValue('100000000'),
+                getContractEnergyShare: vi.fn().mockResolvedValue({
+                    callerPercent: 100,
+                    originEnergyLimit: 0,
+                    originEnergyAvailable: 0,
+                }),
+            },
         });
-        it('builds transaction data with the memo as op return data for a quote', async () => {
+        it('carries the router call as transactionData and simulates it', async () => {
+            const adapter = tronAdapter();
             const actual = await getButterSwapStepData({
                 type: 'quote',
-                input: { xpub: 'zpub6qux' },
-                from: 'bc1qaddress',
-                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: 'butter-memo' },
-                deps: makeDeps({ utxo: utxoAdapter }),
+                input: {},
+                from: 'TSenderAddress',
+                buildTx: tronBuildTx,
+                deps: makeDeps({ tron: adapter }),
                 route,
-                sellAsset: BTC,
-                feeAsset: BTC,
-                sellAmountCryptoBaseUnit: '100000',
+                sellAsset: TRX,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
                 spenderAddress: '',
             });
-            expect(actual.unwrap()).toEqual({
-                networkFeeCryptoBaseUnit: '4200',
-                transactionData: {
-                    type: 'utxo',
-                    to: 'bc1qbridge',
-                    opReturnData: 'butter-memo',
-                    value: '100000',
-                },
+            // Butter's value is the native amount to send: the sell amount for a native sell, 0 for a token
+            const transactionData = {
+                type: 'tron',
+                to: 'TRouterAddress',
+                data: evmBuildTx.data,
+                value: '100000000000000000',
+            };
+            expect(actual.unwrap()).toEqual({ transactionData, networkFeeCryptoBaseUnit: '9000000' });
+            expect(adapter.getFeeData).toHaveBeenCalledWith({
+                to: 'TRouterAddress',
+                value: '100000000000000000',
+                chainSpecific: { from: 'TSenderAddress', data: evmBuildTx.data, requireEnergyShare: true },
             });
         });
-        it('errors when the quote is missing the memo the bridge routes on', async () => {
+        it('uses the provider value for a token sell', async () => {
             const actual = await getButterSwapStepData({
                 type: 'quote',
-                input: { xpub: 'zpub6qux' },
-                from: 'bc1qaddress',
-                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: undefined },
-                deps: makeDeps({ utxo: utxoAdapter }),
+                input: {},
+                from: 'TSenderAddress',
+                buildTx: { ...tronBuildTx, value: '0x00' },
+                deps: makeDeps({ tron: tronAdapter() }),
                 route,
-                sellAsset: BTC,
-                feeAsset: BTC,
-                sellAmountCryptoBaseUnit: '100000',
+                sellAsset: USDT_TRON,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
                 spenderAddress: '',
             });
-            expect(actual.isErr()).toBe(true);
-            expect(actual.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+            expect(actual.unwrap().transactionData).toMatchObject({ value: '0' });
         });
-    });
-    describe('solana', () => {
-        it('uses the provider fee for a rate, since swap instructions do not exist yet', async () => {
-            const assertGetSolanaChainAdapter = vi.fn();
+        it('fails a native quote when the simulation fails', async () => {
+            const adapter = tronAdapter();
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
             const actual = await getButterSwapStepData({
-                type: 'rate',
+                type: 'quote',
                 input: {},
-                deps: { assertGetSolanaChainAdapter },
+                from: 'TSenderAddress',
+                buildTx: tronBuildTx,
+                deps: makeDeps({ tron: adapter }),
                 route,
-                sellAsset: SOL,
-                feeAsset: SOL,
-                sellAmountCryptoBaseUnit: '1000000000',
+                sellAsset: TRX,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
                 spenderAddress: '',
             });
-            expect(actual.unwrap()).toEqual({
-                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
-            });
+            expect(actual.isErr()).toBe(true);
         });
-    });
-    describe('tron', () => {
-        it('returns legacy metadata rather than transaction data, since exec still builds from it', async () => {
-            const buildTx = {
-                ...evmBuildTx,
-                to: 'TRouterAddress',
-                method: 'swapAndCall',
-                args: [{ type: 'address', value: 'TSpender' }],
-            };
+        it('prices the measured worst case when a token allowance is not granted yet', async () => {
+            const adapter = tronAdapter({ allowance: '0' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
             const actual = await getButterSwapStepData({
                 type: 'quote',
                 input: {},
                 from: 'TSenderAddress',
-                buildTx,
-                deps: {},
+                buildTx: { ...tronBuildTx, value: '0x00' },
+                deps: makeDeps({ tron: adapter }),
                 route,
+                sellAsset: USDT_TRON,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
+                spenderAddress: '',
+            });
+            // 1000000 energy * 1.2 margin * 100 sun + (4 calldata + 279 envelope) bytes * 1000 sun
+            expect(actual.unwrap().networkFeeCryptoBaseUnit).toBe('120283000');
+        });
+        it('rates price the measured swap at the router share', async () => {
+            const adapter = tronAdapter();
+            adapter.httpProvider.getContractEnergyShare.mockResolvedValue({
+                callerPercent: 5,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 5_000_000,
+            });
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: {},
+                deps: makeDeps({ tron: adapter }),
+                route: { ...route, contract: 'TRouterAddress' },
                 sellAsset: TRX,
                 feeAsset: TRX,
                 sellAmountCryptoBaseUnit: '1000000',
                 spenderAddress: '',
             });
-            expect(actual.unwrap()).toEqual({
-                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
-                butterSwapTransactionMetadata: {
-                    to: 'TRouterAddress',
-                    data: evmBuildTx.data,
-                    value: evmBuildTx.value,
-                    method: 'swapAndCall',
-                    args: [{ type: 'address', value: 'TSpender' }],
-                    memo: undefined,
-                },
+            // 1000000 * 5% caller energy * 1.2 margin * 100 sun + 2400 bytes * 1000 sun
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '8400000' });
+            expect(adapter.httpProvider.getContractEnergyShare).toHaveBeenCalledWith('TRouterAddress');
+        });
+        it('rates fall back to the provider fee when the worst case cannot be priced', async () => {
+            const adapter = tronAdapter();
+            adapter.httpProvider.getContractEnergyShare.mockRejectedValue(new Error('429'));
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: {},
+                deps: makeDeps({ tron: adapter }),
+                route: { ...route, contract: 'TRouterAddress' },
+                sellAsset: TRX,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
+                spenderAddress: '',
             });
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT });
         });
     });
     it('errors on an unsupported chain namespace', async () => {

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

@@ -1,4 +1,4 @@
-import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { BigAmount, bnOrZero } from '@shapeshiftoss/utils';
@@ -17,7 +17,6 @@ const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
     [avalanche.id]: KnownChainIds.AvalancheMainnet,
     [robinhood.id]: KnownChainIds.RobinhoodMainnet,
     1360108768460801: KnownChainIds.SolanaMainnet,
-    1360095883558913: KnownChainIds.BitcoinMainnet,
     [tron.id]: KnownChainIds.TronMainnet,
 };
 const CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID = Object.entries(BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID).reduce((acc, [butterSwapChainId, chainId]) => {
@@ -32,7 +31,6 @@ export const chainIdToButterSwapChainId = (chainId) => {
 };
 export const assertValidTrade = ({ sellAsset, }) => {
     if (!isEvmChainId(sellAsset.chainId) &&
-        sellAsset.chainId !== btcChainId &&
         sellAsset.chainId !== solanaChainId &&
         sellAsset.chainId !== tronChainId) {
         return Err(makeSwapErrorRight({
@@ -42,8 +40,7 @@ export const assertValidTrade = ({ sellAsset, }) => {
     }
     return Ok(undefined);
 };
-// Provider reported network fee - the rate fallback when estimation fails, and the fee for the
-// un-migrated tron quote path (exec computes the real fee at execution)
+// Provider reported network fee - the fallback when estimation fails
 export const getProviderNetworkFeeCryptoBaseUnit = ({ route, feeAsset, }) => {
     if (bnOrZero(route.gasFee?.amount).lte(0))
         return '0';

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

@@ -1,4 +1,5 @@
 import { fromAssetId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
@@ -20,7 +21,6 @@ export var ButterSwapErrorCode;
     ButterSwapErrorCode[ButterSwapErrorCode["InvalidAddress"] = 2007] = "InvalidAddress";
 })(ButterSwapErrorCode || (ButterSwapErrorCode = {}));
 const SOLANA_NATIVE_ADDRESS = 'So11111111111111111111111111111111111111112';
-const TRON_NATIVE_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
 export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoPrecision, slippage, affiliate, }) => {
     const butterFromChainId = chainIdToButterSwapChainId(sellAsset.chainId);
     const butterToChainId = chainIdToButterSwapChainId(buyAsset.chainId);
@@ -39,7 +39,7 @@ export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoPrec
         if (sellAsset.chainId === solanaChainId && sellAssetIsNative)
             return SOLANA_NATIVE_ADDRESS;
         if (sellAsset.chainId === tronChainId && sellAssetIsNative)
-            return TRON_NATIVE_ADDRESS;
+            return tron.TRON_ZERO_ADDRESS;
         if (sellAssetIsNative)
             return zeroAddress;
         return sellAssetAddressRaw;
@@ -48,7 +48,7 @@ export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoPrec
         if (buyAsset.chainId === solanaChainId && buyAssetIsNative)
             return SOLANA_NATIVE_ADDRESS;
         if (buyAsset.chainId === tronChainId && buyAssetIsNative)
-            return TRON_NATIVE_ADDRESS;
+            return tron.TRON_ZERO_ADDRESS;
         if (buyAssetIsNative)
             return zeroAddress;
         return buyAssetAddressRaw;

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

@@ -1,9 +1,8 @@
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote } from '../../utils/index.js';
+import { getSwapMetadata } from '../../utils/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
-import { getTronTransactionFees } from '../../utils/tron/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
 import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { ChainflipStatusMessage } from './constants.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
@@ -19,22 +18,7 @@ export const chainflipApi = {
     getUtxoTransactionFees,
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
-    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?.depositAddress)
-            throw Error('Missing deposit address');
-        const adapter = assertGetTronChainAdapter(sellAsset.chainId);
-        return adapter.buildSendApiTransaction({
-            to: chainflipSpecific.depositAddress,
-            from,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            accountNumber,
-            chainSpecific: { contractAddress: contractAddressOrUndefined(sellAsset.assetId) },
-        });
-    },
+    getUnsignedTronTransaction,
     getTronTransactionFees,
     checkTradeStatus: async ({ config, swap }) => {
         if (!swap)