@shapeshiftoss/swapper 17.6.6-alpha.0 → 17.6.6

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

@@ -1,180 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

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

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

@@ -1,58 +0,0 @@
-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(),
-            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

@@ -1,3 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

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

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

@@ -1,90 +0,0 @@
-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(),
-            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(),
-            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
-    });
-});