@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,180 @@
+import { solanaChainId } from '@shapeshiftoss/caip';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { Ok } from '@sniptt/monads';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as utils from '../../../utils.js';
+import * as xhr from '../xhr.js';
+import { checkTradeStatus } from './checkTradeStatus.js';
+// Mock the utility functions
+vi.mock('../../../utils', () => ({
+    checkSolanaSwapStatus: vi.fn(),
+    checkEvmSwapStatus: vi.fn(),
+    createDefaultStatusResponse: vi.fn(),
+}));
+// Mock the XHR functions
+vi.mock('../xhr', () => ({
+    getBridgeInfoBySourceHash: vi.fn(),
+}));
+describe('checkTradeStatus same-chain short-circuit', () => {
+    const mockTxHash = '0x123';
+    const mockAddress = '0xabc';
+    const mockEvmChainId = 'eip155:1'; // Ethereum
+    const mockBscChainId = 'eip155:56'; // BSC
+    const mockUnknownChainId = 'cosmos:cosmoshub-4'; // Non-EVM, non-Solana
+    const mockAssertGetEvmChainAdapter = vi.fn();
+    const mockAssertGetSolanaChainAdapter = vi.fn();
+    const mockFetchIsSmartContractAddressQuery = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should call checkSolanaSwapStatus for Solana same-chain swaps', async () => {
+        const mockSolanaStatus = {
+            status: TxStatus.Confirmed,
+            buyTxHash: 'solana-tx',
+            message: undefined,
+        };
+        vi.mocked(utils.checkSolanaSwapStatus).mockResolvedValue(mockSolanaStatus);
+        const input = {
+            txHash: mockTxHash,
+            chainId: solanaChainId,
+            address: mockAddress,
+            swap: {
+                sellAsset: { chainId: solanaChainId },
+                buyAsset: { chainId: solanaChainId },
+            },
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await checkTradeStatus(input);
+        // Assert checkSolanaSwapStatus was called with correct params
+        expect(utils.checkSolanaSwapStatus).toHaveBeenCalledWith({
+            txHash: mockTxHash,
+            address: mockAddress,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+        });
+        // Assert other status checks were NOT called
+        expect(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        expect(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        expect(result).toEqual(mockSolanaStatus);
+    });
+    it('should call checkEvmSwapStatus for EVM same-chain swaps', async () => {
+        const mockEvmStatus = { status: TxStatus.Confirmed, buyTxHash: 'evm-tx', message: undefined };
+        vi.mocked(utils.checkEvmSwapStatus).mockResolvedValue(mockEvmStatus);
+        const input = {
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            swap: {
+                sellAsset: { chainId: mockEvmChainId },
+                buyAsset: { chainId: mockEvmChainId },
+            },
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await checkTradeStatus(input);
+        // Assert checkEvmSwapStatus was called with correct params
+        expect(utils.checkEvmSwapStatus).toHaveBeenCalledWith({
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        });
+        // Assert other status checks were NOT called
+        expect(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        expect(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        expect(result).toEqual(mockEvmStatus);
+    });
+    it('should call createDefaultStatusResponse for unknown same-chain swaps', async () => {
+        const mockDefaultStatus = { status: TxStatus.Pending, buyTxHash: undefined, message: undefined };
+        vi.mocked(utils.createDefaultStatusResponse).mockReturnValue(mockDefaultStatus);
+        const input = {
+            txHash: mockTxHash,
+            chainId: mockUnknownChainId,
+            address: mockAddress,
+            swap: {
+                sellAsset: { chainId: mockUnknownChainId },
+                buyAsset: { chainId: mockUnknownChainId },
+            },
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await checkTradeStatus(input);
+        // Assert createDefaultStatusResponse was called
+        expect(utils.createDefaultStatusResponse).toHaveBeenCalledWith(mockTxHash);
+        // Assert other status checks were NOT called
+        expect(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        expect(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        expect(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        expect(result).toEqual(mockDefaultStatus);
+    });
+    it('should proceed to bridge polling for cross-chain swaps', async () => {
+        const mockBridgeInfo = {
+            id: 12345,
+            state: 1,
+            toHash: 'dest-tx',
+            relayerHash: 'relayer-tx',
+            relayerChain: { scanUrl: 'https://scan.url' },
+        };
+        vi.mocked(xhr.getBridgeInfoBySourceHash).mockResolvedValue(Ok(mockBridgeInfo));
+        const input = {
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            swap: {
+                sellAsset: { chainId: mockEvmChainId },
+                buyAsset: { chainId: mockBscChainId }, // Different chain
+            },
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await checkTradeStatus(input);
+        // Assert bridge polling function was called
+        expect(xhr.getBridgeInfoBySourceHash).toHaveBeenCalledWith(mockTxHash);
+        // Assert same-chain checks were NOT called
+        expect(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        expect(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        expect(utils.createDefaultStatusResponse).not.toHaveBeenCalled();
+        // Assert correct result from bridge polling
+        expect(result).toEqual({
+            status: TxStatus.Confirmed,
+            buyTxHash: 'dest-tx',
+            relayerTxHash: 'relayer-tx',
+            relayerExplorerTxLink: 'https://scan.url',
+            message: undefined,
+        });
+    });
+    it('should handle missing swap data and proceed to bridge polling', async () => {
+        const mockBridgeInfo = {
+            id: 99999,
+            state: 0, // Pending
+        };
+        vi.mocked(xhr.getBridgeInfoBySourceHash).mockResolvedValue(Ok(mockBridgeInfo));
+        const input = {
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            swap: undefined,
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await checkTradeStatus(input);
+        // Assert bridge polling was used (no swap data means can't determine if same-chain)
+        expect(xhr.getBridgeInfoBySourceHash).toHaveBeenCalledWith(mockTxHash);
+        // Assert same-chain checks were NOT called
+        expect(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        expect(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        expect(result.status).toEqual(TxStatus.Pending);
+    });
+});

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput, _deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -0,0 +1,187 @@
+import { btcAssetId, btcChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, fromBaseUnit, toBaseUnit, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
+import { makeButterSwapAffiliate } from '../utils/constants.js';
+import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, fetchTxData, getButterRoute, isBuildTxSuccess, isRouteSuccess, } from '../xhr.js';
+export const getTradeQuote = async (input, _deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, sendAddress, slippageTolerancePercentageDecimal, accountNumber, affiliateBps, } = input;
+    if (!isEvmChainId(sellAsset.chainId) &&
+        sellAsset.chainId !== btcChainId &&
+        sellAsset.chainId !== solanaChainId) {
+        return Err(makeSwapErrorRight({
+            message: `Unsupported chain`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Yes, this is supposed to be supported as per checks above, but currently, Butter doesn't yield any quotes for BTC sells
+    if (sellAsset.assetId === btcAssetId) {
+        return Err(makeSwapErrorRight({
+            message: `BTC sells are currently unsupported`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!sendAddress) {
+        return Err(makeSwapErrorRight({
+            message: '[getTradeQuote] sendAddress is required for ButterSwap',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const slippageDecimal = slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ButterSwap);
+    const slippage = convertDecimalPercentageToBasisPoints(slippageDecimal).toString();
+    // Call ButterSwap /route API
+    const routeResult = await getButterRoute({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoBaseUnit: fromBaseUnit(sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset.precision),
+        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 = toBaseUnit(routeResponse.minAmount, sellAsset.precision);
+            return Err(createTradeAmountTooSmallErr({
+                minAmountCryptoBaseUnit,
+                assetId: sellAsset.assetId,
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: `[getTradeQuote] ${routeResponse.message}`,
+            code: butterSwapErrorToTradeQuoteError(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return Err(makeSwapErrorRight({
+            message: '[getTradeQuote] No route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    // Call ButterSwap /swap API to get calldata and contract info
+    const buildTxResult = await fetchTxData({
+        hash: route.hash,
+        slippage,
+        from: sendAddress,
+        receiver: receiveAddress, // receiver (destination chain address)
+    });
+    if (buildTxResult.isErr())
+        return Err(buildTxResult.unwrapErr());
+    const buildTxResponse = buildTxResult.unwrap();
+    if (!isBuildTxSuccess(buildTxResponse)) {
+        return Err(makeSwapErrorRight({
+            message: `[getTradeQuote] /swap failed: ${buildTxResponse.message}`,
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+    const buildTx = buildTxResponse.data[0];
+    if (!buildTx) {
+        return Err(makeSwapErrorRight({
+            message: '[getTradeQuote] No buildTx data returned',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+    // Fee asset for network fees
+    const feeAsset = _deps.assetsById[chainIdToFeeAssetId(sellAsset.chainId)];
+    if (!feeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getTradeQuote] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Map gasFee.amount to networkFeeCryptoBaseUnit using fee asset precision
+    const networkFeeCryptoBaseUnit = toBaseUnit(bnOrZero(route.gasFee?.amount), feeAsset.precision);
+    // Use destination receive amount as a priority if present and defined
+    // It won't for same-chain swaps, so we fall back to the source chain receive amount (i.e source chain *is* the destination chain)
+    const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
+    // TODO: affiliate fees not yet here, gut feel is that Butter won't do the swap output - fees logic for us here
+    // Sanity check me when affiliates are implemented, and do the math ourselves if needed
+    const buyAmountAfterFeesCryptoBaseUnit = toBaseUnit(outputAmount, buyAsset.precision);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    // Extract Solana transaction metadata from versioned transaction, to allow building an unsigned Tx later on at getUnsignedSolanaTransaction time
+    const maybeSolanaTransactionMetadata = await (async () => {
+        if (sellAsset.chainId !== solanaChainId)
+            return Ok(undefined);
+        const txData = buildTx.data.startsWith('0x') ? buildTx.data.slice(2) : buildTx.data;
+        const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(Buffer.from(txData, 'hex')));
+        const adapter = _deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+        try {
+            const addressLookupTableAccountKeys = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
+            const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAccountKeys);
+            const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new AddressLookupTableAccount({
+                key: new PublicKey(info.key),
+                state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+            }));
+            // Decompile VersionedMessage with address lookup tables to get instructions
+            // This is required to properly resolve all account addresses in the transaction
+            // Without lookup tables, the transaction would fail during execution
+            // Reference: https://dev.jup.ag/docs/old/additional-topics/composing-with-versioned-transaction
+            const instructions = TransactionMessage.decompile(versionedTransaction.message, {
+                addressLookupTableAccounts,
+            }).instructions;
+            return Ok({
+                instructions,
+                addressLookupTableAddresses: addressLookupTableAccountKeys,
+            });
+        }
+        catch (error) {
+            return Err(makeSwapErrorRight({
+                message: `[getTradeQuote] Error decompiling VersionedMessage: ${error}`,
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+    })();
+    if (sellAsset.chainId === solanaChainId && maybeSolanaTransactionMetadata?.isErr()) {
+        return Err(maybeSolanaTransactionMetadata.unwrapErr());
+    }
+    const solanaTransactionMetadata = maybeSolanaTransactionMetadata?.unwrap();
+    const step = {
+        buyAmountBeforeFeesCryptoBaseUnit: toBaseUnit(outputAmount, buyAsset.precision),
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: undefined,
+        },
+        rate,
+        source: SwapperName.ButterSwap,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        allowanceContract: route.contract ?? '0x0',
+        estimatedExecutionTimeMs: route.timeEstimated * 1000,
+        butterSwapTransactionMetadata: {
+            to: buildTx.to,
+            data: buildTx.data,
+            value: buildTx.value,
+            gasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
+        },
+        ...(solanaTransactionMetadata && {
+            solanaTransactionMetadata,
+        }),
+    };
+    const tradeQuote = {
+        id: route.hash,
+        rate,
+        receiveAddress,
+        affiliateBps,
+        isStreaming: false,
+        quoteOrRate: 'quote',
+        swapperName: SwapperName.ButterSwap,
+        slippageTolerancePercentageDecimal: slippageDecimal,
+        steps: [step],
+    };
+    return Ok([tradeQuote]);
+};

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,62 @@
+import { Ok } from '@sniptt/monads';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH, USDC_MAINNET, WETH } from '../../utils/test-data/assets.js';
+import { ROUTE_QUOTE } from '../test-data/routeQuote.js';
+import { getTradeQuote } from './getTradeQuote.js';
+vi.mock('../xhr', () => ({
+    getButterRoute: vi.fn(() => Promise.resolve(Ok(ROUTE_QUOTE))),
+    fetchTxData: vi.fn(() => Promise.resolve(Ok({
+        data: [
+            {
+                to: '0xContractAddress',
+                data: '0xCalldata',
+                value: '0',
+                chainId: 1,
+                method: 'swap',
+            },
+        ],
+        errno: 0,
+        message: 'success',
+    }))),
+    isRouteSuccess: () => true,
+    isBuildTxSuccess: () => true,
+}));
+describe('getTradeQuote', () => {
+    it('should return a trade quote', async () => {
+        const deps = {
+            assetsById: { [ETH.assetId]: ETH },
+            assertGetChainAdapter: () => vi.fn(),
+            assertGetEvmChainAdapter: () => vi.fn(),
+            assertGetUtxoChainAdapter: () => vi.fn(),
+            assertGetCosmosSdkChainAdapter: () => vi.fn(),
+            assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => vi.fn(),
+            config: {
+                VITE_BUTTERSWAP_CLIENT_ID: 'test',
+            },
+            mixPanel: undefined,
+            fetchIsSmartContractAddressQuery: vi.fn(),
+        };
+        const input = {
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+            sellAsset: WETH,
+            buyAsset: USDC_MAINNET,
+            sendAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+            receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+            accountNumber: 0,
+            affiliateBps: '0',
+            allowMultiHop: true,
+            quoteOrRate: 'quote',
+        };
+        const result = await getTradeQuote(input, deps);
+        expect(result.isOk()).toBe(true);
+        const tradeQuote = result.unwrap();
+        // Use the actual returned value for the expected rate
+        expect(tradeQuote[0].rate).toBe('2296.409699');
+        // 1 WETH in base units
+        expect(tradeQuote[0].steps[0].sellAmountIncludingProtocolFeesCryptoBaseUnit).toBe('1000000000000000000');
+    });
+});

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, _deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -0,0 +1,115 @@
+import { btcAssetId, btcChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { bn, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, toBaseUnit, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
+import { makeButterSwapAffiliate } from '../utils/constants.js';
+import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, getButterRoute, isRouteSuccess, } from '../xhr.js';
+export const getTradeRate = async (input, _deps) => {
+    const { sellAsset, buyAsset, affiliateBps, accountNumber, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    if (!isEvmChainId(sellAsset.chainId) &&
+        sellAsset.chainId !== btcChainId &&
+        sellAsset.chainId !== solanaChainId) {
+        return Err(makeSwapErrorRight({
+            message: `Unsupported chain`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Yes, this is supposed to be supported as per checks above, but currently, Butter doesn't yield any quotes for BTC sells
+    if (sellAsset.assetId === btcAssetId) {
+        return Err(makeSwapErrorRight({
+            message: `BTC sells are currently unsupported`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const amount = bn(sellAmountIncludingProtocolFeesCryptoBaseUnit)
+        .shiftedBy(-sellAsset.precision)
+        .toString();
+    const feeAssetId = chainIdToFeeAssetId(sellAsset.chainId);
+    const slippageTolerancePercentageDecimal = getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ButterSwap);
+    const slippage = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toString();
+    const result = await getButterRoute({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoBaseUnit: amount,
+        slippage,
+        affiliate: makeButterSwapAffiliate(affiliateBps),
+    });
+    if (result.isErr()) {
+        return Err(result.unwrapErr());
+    }
+    const routeResponse = result.unwrap();
+    if (!isRouteSuccess(routeResponse)) {
+        if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
+            const minAmountCryptoBaseUnit = toBaseUnit(routeResponse.minAmount, sellAsset.precision);
+            return Err(createTradeAmountTooSmallErr({
+                minAmountCryptoBaseUnit,
+                assetId: sellAsset.assetId,
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: `[getTradeRate] ${routeResponse.message}`,
+            code: butterSwapErrorToTradeQuoteError(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return Err(makeSwapErrorRight({
+            message: '[getTradeRate] No route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    // Use destination receive amount as a priority if present and defined
+    // It won't for same-chain swaps, so we fall back to the source chain receive amount (i.e source chain *is* the destination chain)
+    const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
+    // TODO: affiliate fees not yet here, gut feel is that Butter won't do the swap output - fees logic for us here
+    // Sanity check me when affiliates are implemented, and do the math ourselves if needed
+    const buyAmountAfterFeesCryptoBaseUnit = toBaseUnit(outputAmount, buyAsset.precision);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const feeAsset = _deps.assetsById[feeAssetId];
+    if (!feeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getTradeRate] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Map gasFee.amount to networkFeeCryptoBaseUnit using fee asset precision
+    const networkFeeCryptoBaseUnit = bnOrZero(route.gasFee?.amount).gt(0)
+        ? toBaseUnit(route.gasFee.amount, feeAsset.precision)
+        : '0';
+    // Always a single step
+    const step = {
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit: toBaseUnit(outputAmount, buyAsset.precision),
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: undefined,
+        },
+        source: SwapperName.ButterSwap,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        allowanceContract: route.contract ?? '0x0',
+        estimatedExecutionTimeMs: route.timeEstimated * 1000,
+    };
+    const tradeRate = {
+        id: route.hash,
+        rate,
+        swapperName: SwapperName.ButterSwap,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        quoteOrRate: 'rate',
+        steps: [step],
+    };
+    return Ok([tradeRate]);
+};

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,98 @@
+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 { ROUTE_QUOTE } from '../test-data/routeQuote.js';
+import { butterService } from '../utils/butterSwapService.js';
+import { getTradeRate } from './getTradeRate.js';
+vi.mock('../utils/butterSwapService', () => ({
+    butterService: {
+        get: vi.fn(),
+    },
+}));
+describe('getTradeRate', () => {
+    it('should return a trade rate', async () => {
+        const deps = {
+            assetsById: { [ETH.assetId]: ETH },
+            assertGetChainAdapter: () => vi.fn(),
+            assertGetEvmChainAdapter: () => vi.fn(),
+            assertGetUtxoChainAdapter: () => vi.fn(),
+            assertGetCosmosSdkChainAdapter: () => vi.fn(),
+            assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => vi.fn(),
+            config: {
+                VITE_BUTTERSWAP_CLIENT_ID: 'test',
+            },
+            mixPanel: undefined,
+            fetchIsSmartContractAddressQuery: vi.fn(),
+        };
+        const input = {
+            sellAsset: WETH,
+            buyAsset: USDC_MAINNET,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: bn(1).shiftedBy(18).toString(),
+            affiliateBps: '0',
+            allowMultiHop: true,
+            receiveAddress: '0x123',
+            accountNumber: undefined,
+            quoteOrRate: 'rate',
+            chainId: KnownChainIds.EthereumMainnet,
+            supportsEIP1559: false, // TODO - upstream type bug? this is a literal false in the type def
+        };
+        vi.mocked(butterService.get).mockResolvedValue(Ok({ data: ROUTE_QUOTE }));
+        const result = await getTradeRate(input, deps);
+        expect(result.isOk()).toBe(true);
+        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: () => vi.fn(),
+            assertGetUtxoChainAdapter: () => vi.fn(),
+            assertGetCosmosSdkChainAdapter: () => vi.fn(),
+            assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
+            assertGetNearChainAdapter: () => vi.fn(),
+            assertGetStarknetChainAdapter: () => 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
+    });
+});