@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -0,0 +1,195 @@
+import { CHAIN_NAMESPACE, fromChainId } from '@shapeshiftoss/caip';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
+import { fromHex } from 'viem';
+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 { 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
+export const BUTTERSWAP_SOLANA_COMPUTE_BUDGET = {
+    marginMultiplier: 1.4,
+};
+export async function getButterSwapStepData(args) {
+    const { input, route, sellAsset, feeAsset, sellAmountCryptoBaseUnit, spenderAddress, deps } = args;
+    const { chainNamespace, chainReference } = fromChainId(sellAsset.chainId);
+    switch (chainNamespace) {
+        case CHAIN_NAMESPACE.Evm: {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+            if (args.type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    try {
+                        return await getEvmNetworkFeeCryptoBaseUnit({
+                            adapter,
+                            supportsEIP1559,
+                            gasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
+                        });
+                    }
+                    catch {
+                        return getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
+                    }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            const { buildTx, from } = args;
+            const transactionData = {
+                type: 'evm',
+                chainId: Number(chainReference),
+                to: buildTx.to,
+                data: buildTx.data,
+                value: fromHex(buildTx.value, 'bigint').toString(),
+            };
+            try {
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    supportsEIP1559,
+                    transactionData,
+                    from,
+                    // Butter's gasEstimatedTarget lands short on chain (observed 24% under actual, causing
+                    // in-flight OOG/SWAP_FAIL reverts) - estimate ourselves instead
+                    stateOverride: {
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                    },
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                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') {
+                // Swap instructions don't exist for rates - best effort with provider fee fallback
+                const networkFeeCryptoBaseUnit = getProviderNetworkFeeCryptoBaseUnit({ route, feeAsset });
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            const { buildTx, from } = args;
+            try {
+                const txData = buildTx.data.startsWith('0x') ? buildTx.data.slice(2) : buildTx.data;
+                const txBytes = Buffer.from(txData, 'hex');
+                const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
+                const addressLookupTableAddresses = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
+                const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+                const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new AddressLookupTableAccount({
+                    key: new PublicKey(info.key),
+                    state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+                }));
+                const instructions = omitComputeBudgetInstructions(TransactionMessage.decompile(versionedTransaction.message, { addressLookupTableAccounts })
+                    .instructions);
+                try {
+                    const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await getSolanaNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        from,
+                        instructions,
+                        addressLookupTableAddresses,
+                    });
+                    const transactionData = {
+                        type: 'solana_instructions',
+                        instructions: withComputeUnitLimit({
+                            instructions,
+                            computeUnits: feeData.chainSpecific.computeUnits,
+                            includeComputeBudget,
+                            computeBudget: BUTTERSWAP_SOLANA_COMPUTE_BUDGET,
+                        }),
+                        addressLookupTableAddresses,
+                    };
+                    const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                catch (error) {
+                    return Err(makeNetworkFeeEstimationFailedErr('getButterSwapStepData', error));
+                }
+            }
+            catch (error) {
+                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 });
+            if (args.type === 'rate') {
+                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,
+            };
+            return Ok(stepData);
+        }
+        default:
+            return Err(makeSwapErrorRight({
+                message: `[getButterSwapStepData] unsupported chain namespace: ${chainNamespace}`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+    }
+}

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

@@ -0,0 +1,263 @@
+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 { 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
+// mocked adapter
+vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vi.fn().mockResolvedValue(undefined),
+}));
+const route = ROUTE_QUOTE.data[0];
+// The provider gas fee, in human units, that every fallback path prices off of
+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 evmBuildTx = {
+    to: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    data: '0xdeadbeef',
+    value: '0x16345785d8a0000',
+    chainId: '1',
+};
+const makeDeps = (adapters) => ({
+    assertGetEvmChainAdapter: () => adapters.evm,
+    assertGetUtxoChainAdapter: () => adapters.utxo,
+    assertGetSolanaChainAdapter: () => adapters.solana,
+});
+const evmAdapter = ({ gasPrice = '1000000000', estimatedGasLimit = '500000', throwOnGasFeeData = false, throwOnFeeData = false, } = {}) => ({
+    getGasFeeData: () => {
+        if (throwOnGasFeeData)
+            return Promise.reject(new Error('rpc down'));
+        return Promise.resolve({ average: { gasPrice, maxFeePerGas: '0', maxPriorityFeePerGas: '0' } });
+    },
+    getFeeData: () => {
+        if (throwOnFeeData)
+            return Promise.reject(new Error('execution reverted'));
+        return Promise.resolve({
+            average: { chainSpecific: { gasLimit: estimatedGasLimit, gasPrice } },
+        });
+    },
+});
+const evmRateInput = { supportsEIP1559: false };
+const evmQuoteInput = { supportsEIP1559: false };
+describe('getButterSwapStepData', () => {
+    describe('evm', () => {
+        it('prices the provider gas limit for a rate', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter() }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 * gasPrice 1000000000
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '1159118000000000' });
+        });
+        it('falls back to the provider fee when rate estimation fails', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter({ throwOnGasFeeData: true }) }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+        it('estimates gas on chain for a quote instead of trusting the provider target', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 is ignored - the tx carries the buffered on chain estimate
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '500000000000000',
+                transactionData: {
+                    type: 'evm',
+                    chainId: 1,
+                    to: evmBuildTx.to,
+                    data: evmBuildTx.data,
+                    value: '100000000000000000',
+                    gasLimit: '600000',
+                },
+            });
+        });
+        it('estimates gas on chain for a quote when the provider omits a target', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            const { transactionData, networkFeeCryptoBaseUnit } = actual.unwrap();
+            // The buffered limit is set on the tx data in place, so the executable tx always carries one
+            expect(transactionData).toMatchObject({ gasLimit: '600000' });
+            expect(networkFeeCryptoBaseUnit).toBe('500000000000000');
+        });
+        it('errors rather than falling back to the provider fee when quote estimation fails', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ throwOnFeeData: true }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            expect(actual.isErr()).toBe(true);
+            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 () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: {},
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            // 10 sats/byte * 200 vbyte default
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '2000' });
+        });
+        it('builds transaction data with the memo as op return data for a quote', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: 'butter-memo' },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '4200',
+                transactionData: {
+                    type: 'utxo',
+                    to: 'bc1qbridge',
+                    opReturnData: 'butter-memo',
+                    value: '100000',
+                },
+            });
+        });
+        it('errors when the quote is missing the memo the bridge routes on', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: undefined },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            expect(actual.isErr()).toBe(true);
+            expect(actual.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+        });
+    });
+    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: { assertGetSolanaChainAdapter },
+                route,
+                sellAsset: SOL,
+                feeAsset: SOL,
+                sellAmountCryptoBaseUnit: '1000000000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+    });
+    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' }],
+            };
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: {},
+                from: 'TSenderAddress',
+                buildTx,
+                deps: {},
+                route,
+                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,
+                },
+            });
+        });
+    });
+    it('errors on an unsupported chain namespace', async () => {
+        const actual = await getButterSwapStepData({
+            type: 'rate',
+            input: {},
+            deps: {},
+            route,
+            sellAsset: RUNE,
+            feeAsset: RUNE,
+            sellAmountCryptoBaseUnit: '100000000',
+            spenderAddress: '',
+        });
+        expect(actual.isErr()).toBe(true);
+        expect(actual.unwrapErr().code).toBe(TradeQuoteError.UnsupportedChain);
+    });
+});

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

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { ButterSwapTradeQuoteInput, ButterSwapTradeRateInput, RouteSuccessItem } from '../types.js';
+import type { GetButterSwapStepDataArgs } from './getButterSwapStepData.js';
+type ButterSwapTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    route: RouteSuccessItem;
+    stepDataArgs: Omit<GetButterSwapStepDataArgs, 'type' | 'input' | 'from' | 'buildTx'>;
+};
+export declare const getButterSwapTradeContext: ({ input, deps, slippageTolerancePercentageDecimal, }: {
+    input: ButterSwapTradeQuoteInput | ButterSwapTradeRateInput;
+    deps: SwapperDeps;
+    slippageTolerancePercentageDecimal: string;
+}) => Promise<Result<ButterSwapTradeContext, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,107 @@
+import { BigAmount, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, getButterRoute, isRouteSuccess, } from '../xhr.js';
+import { makeButterSwapAffiliate } from './constants.js';
+import { assertValidTrade } from './helpers.js';
+export const getButterSwapTradeContext = async ({ input, deps, slippageTolerancePercentageDecimal, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const slippage = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toString();
+    const routeResult = await getButterRoute({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoPrecision: BigAmount.fromBaseUnit({
+            value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            precision: sellAsset.precision,
+        }).toPrecision(),
+        slippage,
+        affiliate: makeButterSwapAffiliate(affiliateBps),
+    });
+    if (routeResult.isErr())
+        return Err(routeResult.unwrapErr());
+    const routeResponse = routeResult.unwrap();
+    if (!isRouteSuccess(routeResponse)) {
+        if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
+            const minAmountCryptoBaseUnit = BigAmount.fromPrecision({
+                value: routeResponse.minAmount,
+                precision: sellAsset.precision,
+            }).toBaseUnit();
+            return Err(createTradeAmountTooSmallErr({ minAmountCryptoBaseUnit, assetId: sellAsset.assetId }));
+        }
+        return Err(makeSwapErrorRight({
+            message: `[getButterSwapTradeContext] ${routeResponse.message}`,
+            code: butterSwapErrorToTradeQuoteError(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return Err(makeSwapErrorRight({
+            message: '[getButterSwapTradeContext] No route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const feeAsset = deps.assetsById[chainIdToFeeAssetId(sellAsset.chainId)];
+    if (!feeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getButterSwapTradeContext] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Destination receive amount takes priority; same-chain swaps only carry a source chain amount
+    const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
+    const buyAmountAfterFeesCryptoBaseUnit = BigAmount.fromPrecision({
+        value: outputAmount,
+        precision: buyAsset.precision,
+    }).toBaseUnit();
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    return Ok({
+        tradeCommon: {
+            id: route.hash,
+            rate,
+            swapperName: SwapperName.ButterSwap,
+            affiliateBps,
+            isStreaming: false,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: SwapperName.ButterSwap,
+            buyAsset,
+            sellAsset,
+            allowanceContract: route.contract ?? '',
+            estimatedExecutionTimeMs: route.timeEstimated * 1000,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees: undefined,
+        route,
+        stepDataArgs: {
+            route,
+            feeAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            spenderAddress: route.contract ?? '',
+            deps,
+        },
+    });
+};

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

@@ -1,3 +1,14 @@
 import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { RouteSuccessItem } from '../types.js';
 export declare const butterSwapChainIdToChainId: (butterSwapChainId: number) => ChainId | undefined;
 export declare const chainIdToButterSwapChainId: (chainId: ChainId) => number | undefined;
+export declare const assertValidTrade: ({ sellAsset, }: {
+    sellAsset: Asset;
+}) => Result<void, SwapErrorRight>;
+export declare const getProviderNetworkFeeCryptoBaseUnit: ({ route, feeAsset, }: {
+    route: RouteSuccessItem;
+    feeAsset: Asset;
+}) => string;

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

@@ -1,4 +1,10 @@
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { KnownChainIds } from '@shapeshiftoss/types';
+import { BigAmount, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 // https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/get-supportedchainlist#butter-chain-id-explanation
 const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
     1: KnownChainIds.EthereumMainnet,
@@ -22,3 +28,25 @@ export const butterSwapChainIdToChainId = (butterSwapChainId) => {
 export const chainIdToButterSwapChainId = (chainId) => {
     return CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID[chainId];
 };
+export const assertValidTrade = ({ sellAsset, }) => {
+    if (!isEvmChainId(sellAsset.chainId) &&
+        sellAsset.chainId !== btcChainId &&
+        sellAsset.chainId !== solanaChainId &&
+        sellAsset.chainId !== tronChainId) {
+        return Err(makeSwapErrorRight({
+            message: `Unsupported chain`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    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)
+export const getProviderNetworkFeeCryptoBaseUnit = ({ route, feeAsset, }) => {
+    if (bnOrZero(route.gasFee?.amount).lte(0))
+        return '0';
+    return BigAmount.fromPrecision({
+        value: route.gasFee.amount,
+        precision: feeAsset.precision,
+    }).toBaseUnit();
+};

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

@@ -3,8 +3,8 @@ import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
 import { TradeQuoteError } from '../../types.js';
-import { makeSwapErrorRight } from '../../utils.js';
-import { getTreasuryAddressFromChainId } from '../utils/helpers/helpers.js';
+import { makeSwapErrorRight } from '../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers.js';
 import { butterHistoryService } from './utils/butterSwapHistoryService.js';
 import { butterService } from './utils/butterSwapService.js';
 import { chainIdToButterSwapChainId } from './utils/helpers.js';

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

@@ -5,18 +5,14 @@ import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { bnOrZero } from '@shapeshiftoss/utils';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../constants.js';
 import { SwapperName } from '../../types.js';
-import { checkSuiSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkSuiSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
 import { PYTH_DEPENDENT_PROVIDERS } from './utils/constants.js';
 import { findBestRoute, getAggregatorClient, getCoinType, getSuiClient } from './utils/helpers.js';
 export const cetusApi = {
-    getTradeQuote: (input, deps) => {
-        return getTradeQuote(input, deps);
-    },
-    getTradeRate: (input, deps) => {
-        return getTradeRate(input, deps);
-    },
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
     getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, config, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');