@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.butterSwapApi = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const getSolanaTransactionFees_1 = require("../../solana-utils/getSolanaTransactionFees");
+const getUnsignedSolanaTransaction_1 = require("../../solana-utils/getUnsignedSolanaTransaction");
+const utils_1 = require("../../utils");
+const checkTradeStatus_1 = require("./swapperApi/checkTradeStatus");
+const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
+const getTradeRate_1 = require("./swapperApi/getTradeRate");
+exports.butterSwapApi = {
+    getTradeQuote: getTradeQuote_1.getTradeQuote,
+    getTradeRate: getTradeRate_1.getTradeRate,
+    checkTradeStatus: checkTradeStatus_1.checkTradeStatus,
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { butterSwapTransactionMetadata, sellAsset } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({
+            adapter,
+            data,
+            to,
+            value: BigInt(value).toString(),
+            from,
+            supportsEIP1559,
+        });
+        const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+            gasLimit,
+            gasPrice: feeData.gasPrice ?? '0',
+            maxFeePerGas: feeData.maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+            supportsEIP1559,
+        });
+        return bignumber_js_1.default.max(feeData.networkFeeCryptoBaseUnit, networkFeeCryptoBaseUnit).toFixed();
+    },
+    getUnsignedEvmTransaction: async (args) => {
+        const { from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter } = args;
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, butterSwapTransactionMetadata } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({
+            adapter,
+            data,
+            to,
+            value: BigInt(value).toString(),
+            from,
+            supportsEIP1559,
+        });
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            to,
+            value: BigInt(value).toString(),
+            ...feeData,
+            gasLimit: bignumber_js_1.default.max(feeData.gasLimit, gasLimit).toFixed(),
+        });
+    },
+    getUnsignedSolanaTransaction: getUnsignedSolanaTransaction_1.getUnsignedSolanaTransaction,
+    getSolanaTransactionFees: getSolanaTransactionFees_1.getSolanaTransactionFees,
+};

package/dist/cjs/swappers/ButterSwap/index.d.ts

@@ -0,0 +1 @@
+export * from './endpoints';

package/dist/cjs/swappers/ButterSwap/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./endpoints"), exports);

package/dist/cjs/swappers/ButterSwap/swapperApi/checkTradeStatus.d.ts

@@ -0,0 +1,2 @@
+import type { CheckTradeStatusInput, TradeStatus } from '../../../types';
+export declare const checkTradeStatus: (input: CheckTradeStatusInput) => Promise<TradeStatus>;

package/dist/cjs/swappers/ButterSwap/swapperApi/checkTradeStatus.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTradeStatus = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("../../../utils");
+const xhr_1 = require("../xhr");
+// See: https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
+// Example endpoint: https://bs-app-api.chainservice.io/api/queryBridgeInfoBySourceHash?hash=0x...
+// State mapping: 0 = pending, 1 = complete, 6 = refunded/failed
+const BUTTER_SWAP_STATES = (() => ({
+    Pending: 0,
+    Confirmed: 1,
+    Failed: 6,
+}))();
+const checkTradeStatus = async (input) => {
+    const { txHash, chainId: sellChainId, address, swap, assertGetEvmChainAdapter, assertGetSolanaChainAdapter, fetchIsSmartContractAddressQuery, } = input;
+    try {
+        // Same-chain swaps don't go through the bridge indexer. Short-circuit to on-chain status.
+        const isSameChainSwap = Boolean(swap && swap.sellAsset.chainId === swap.buyAsset?.chainId);
+        if (isSameChainSwap) {
+            if (sellChainId === caip_1.solanaChainId) {
+                return await (0, utils_1.checkSolanaSwapStatus)({
+                    txHash,
+                    address,
+                    assertGetSolanaChainAdapter,
+                });
+            }
+            if ((0, chain_adapters_1.isEvmChainId)(sellChainId)) {
+                return await (0, utils_1.checkEvmSwapStatus)({
+                    txHash,
+                    chainId: sellChainId,
+                    address,
+                    assertGetEvmChainAdapter,
+                    fetchIsSmartContractAddressQuery,
+                });
+            }
+            // Fallback: unknown same-chain type (should never happen for Butter, but just in case). Avoid bridge polling.
+            return (0, utils_1.createDefaultStatusResponse)(txHash);
+        }
+        // Fetch bridge info by source hash
+        const infoResult = await (0, xhr_1.getBridgeInfoBySourceHash)(txHash);
+        if (infoResult.isErr()) {
+            const error = infoResult.unwrapErr();
+            return {
+                status: unchained_client_1.TxStatus.Unknown,
+                buyTxHash: undefined,
+                message: error.message,
+            };
+        }
+        const bridgeInfo = infoResult.unwrap();
+        if (!bridgeInfo) {
+            return { status: unchained_client_1.TxStatus.Unknown, buyTxHash: undefined, message: undefined };
+        }
+        // Use toHash as the destination chain tx hash if present
+        const destinationTxHash = bridgeInfo.toHash ?? undefined;
+        const relayerTxHash = bridgeInfo.relayerHash ?? undefined;
+        const relayerExplorerTxLink = bridgeInfo.relayerChain?.scanUrl ?? undefined;
+        // State mapping: 0 = pending, 1 = complete, 6 = refunded/failed
+        let status = (() => {
+            // Optimistically return Confirmed if we have a destination tx hash, useful to chains with long block
+            // times (e.g. BTC)
+            if (!!destinationTxHash)
+                return unchained_client_1.TxStatus.Confirmed;
+            switch (bridgeInfo.state) {
+                case BUTTER_SWAP_STATES.Pending:
+                    return unchained_client_1.TxStatus.Pending;
+                case BUTTER_SWAP_STATES.Confirmed:
+                    return unchained_client_1.TxStatus.Confirmed;
+                case BUTTER_SWAP_STATES.Failed:
+                    return unchained_client_1.TxStatus.Failed;
+                default:
+                    return unchained_client_1.TxStatus.Unknown;
+            }
+        })();
+        return {
+            status,
+            buyTxHash: destinationTxHash,
+            relayerTxHash,
+            relayerExplorerTxLink,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        return { status: unchained_client_1.TxStatus.Unknown, buyTxHash: undefined, message: e.message };
+    }
+};
+exports.checkTradeStatus = checkTradeStatus;

package/dist/cjs/swappers/ButterSwap/swapperApi/checkTradeStatus.test.d.ts

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

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

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const monads_1 = require("@sniptt/monads");
+const vitest_1 = require("vitest");
+const utils = __importStar(require("../../../utils"));
+const xhr = __importStar(require("../xhr"));
+const checkTradeStatus_1 = require("./checkTradeStatus");
+// Mock the utility functions
+vitest_1.vi.mock('../../../utils', () => ({
+    checkSolanaSwapStatus: vitest_1.vi.fn(),
+    checkEvmSwapStatus: vitest_1.vi.fn(),
+    createDefaultStatusResponse: vitest_1.vi.fn(),
+}));
+// Mock the XHR functions
+vitest_1.vi.mock('../xhr', () => ({
+    getBridgeInfoBySourceHash: vitest_1.vi.fn(),
+}));
+(0, vitest_1.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 = vitest_1.vi.fn();
+    const mockAssertGetSolanaChainAdapter = vitest_1.vi.fn();
+    const mockFetchIsSmartContractAddressQuery = vitest_1.vi.fn();
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should call checkSolanaSwapStatus for Solana same-chain swaps', async () => {
+        const mockSolanaStatus = {
+            status: unchained_client_1.TxStatus.Confirmed,
+            buyTxHash: 'solana-tx',
+            message: undefined,
+        };
+        vitest_1.vi.mocked(utils.checkSolanaSwapStatus).mockResolvedValue(mockSolanaStatus);
+        const input = {
+            txHash: mockTxHash,
+            chainId: caip_1.solanaChainId,
+            address: mockAddress,
+            swap: {
+                sellAsset: { chainId: caip_1.solanaChainId },
+                buyAsset: { chainId: caip_1.solanaChainId },
+            },
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await (0, checkTradeStatus_1.checkTradeStatus)(input);
+        // Assert checkSolanaSwapStatus was called with correct params
+        (0, vitest_1.expect)(utils.checkSolanaSwapStatus).toHaveBeenCalledWith({
+            txHash: mockTxHash,
+            address: mockAddress,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+        });
+        // Assert other status checks were NOT called
+        (0, vitest_1.expect)(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        (0, vitest_1.expect)(result).toEqual(mockSolanaStatus);
+    });
+    (0, vitest_1.it)('should call checkEvmSwapStatus for EVM same-chain swaps', async () => {
+        const mockEvmStatus = { status: unchained_client_1.TxStatus.Confirmed, buyTxHash: 'evm-tx', message: undefined };
+        vitest_1.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 (0, checkTradeStatus_1.checkTradeStatus)(input);
+        // Assert checkEvmSwapStatus was called with correct params
+        (0, vitest_1.expect)(utils.checkEvmSwapStatus).toHaveBeenCalledWith({
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        });
+        // Assert other status checks were NOT called
+        (0, vitest_1.expect)(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        (0, vitest_1.expect)(result).toEqual(mockEvmStatus);
+    });
+    (0, vitest_1.it)('should call createDefaultStatusResponse for unknown same-chain swaps', async () => {
+        const mockDefaultStatus = { status: unchained_client_1.TxStatus.Pending, buyTxHash: undefined, message: undefined };
+        vitest_1.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 (0, checkTradeStatus_1.checkTradeStatus)(input);
+        // Assert createDefaultStatusResponse was called
+        (0, vitest_1.expect)(utils.createDefaultStatusResponse).toHaveBeenCalledWith(mockTxHash);
+        // Assert other status checks were NOT called
+        (0, vitest_1.expect)(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(xhr.getBridgeInfoBySourceHash).not.toHaveBeenCalled();
+        // Assert correct result
+        (0, vitest_1.expect)(result).toEqual(mockDefaultStatus);
+    });
+    (0, vitest_1.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' },
+        };
+        vitest_1.vi.mocked(xhr.getBridgeInfoBySourceHash).mockResolvedValue((0, monads_1.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 (0, checkTradeStatus_1.checkTradeStatus)(input);
+        // Assert bridge polling function was called
+        (0, vitest_1.expect)(xhr.getBridgeInfoBySourceHash).toHaveBeenCalledWith(mockTxHash);
+        // Assert same-chain checks were NOT called
+        (0, vitest_1.expect)(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(utils.createDefaultStatusResponse).not.toHaveBeenCalled();
+        // Assert correct result from bridge polling
+        (0, vitest_1.expect)(result).toEqual({
+            status: unchained_client_1.TxStatus.Confirmed,
+            buyTxHash: 'dest-tx',
+            relayerTxHash: 'relayer-tx',
+            relayerExplorerTxLink: 'https://scan.url',
+            message: undefined,
+        });
+    });
+    (0, vitest_1.it)('should handle missing swap data and proceed to bridge polling', async () => {
+        const mockBridgeInfo = {
+            id: 99999,
+            state: 0, // Pending
+        };
+        vitest_1.vi.mocked(xhr.getBridgeInfoBySourceHash).mockResolvedValue((0, monads_1.Ok)(mockBridgeInfo));
+        const input = {
+            txHash: mockTxHash,
+            chainId: mockEvmChainId,
+            address: mockAddress,
+            swap: undefined,
+            assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
+            assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
+            fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,
+        };
+        const result = await (0, checkTradeStatus_1.checkTradeStatus)(input);
+        // Assert bridge polling was used (no swap data means can't determine if same-chain)
+        (0, vitest_1.expect)(xhr.getBridgeInfoBySourceHash).toHaveBeenCalledWith(mockTxHash);
+        // Assert same-chain checks were NOT called
+        (0, vitest_1.expect)(utils.checkSolanaSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(utils.checkEvmSwapStatus).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(result.status).toEqual(unchained_client_1.TxStatus.Pending);
+    });
+});

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

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

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

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_2 = require("../utils/constants");
+const xhr_1 = require("../xhr");
+const getTradeQuote = async (input, _deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, sendAddress, slippageTolerancePercentageDecimal, accountNumber, affiliateBps, } = input;
+    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) &&
+        sellAsset.chainId !== caip_1.btcChainId &&
+        sellAsset.chainId !== caip_1.solanaChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Unsupported chain`,
+            code: types_1.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 === caip_1.btcAssetId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `BTC sells are currently unsupported`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!sendAddress) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[getTradeQuote] sendAddress is required for ButterSwap',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const slippageDecimal = slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.ButterSwap);
+    const slippage = (0, utils_1.convertDecimalPercentageToBasisPoints)(slippageDecimal).toString();
+    // Call ButterSwap /route API
+    const routeResult = await (0, xhr_1.getButterRoute)({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoBaseUnit: (0, utils_1.fromBaseUnit)(sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset.precision),
+        slippage,
+        affiliate: (0, constants_2.makeButterSwapAffiliate)(affiliateBps),
+    });
+    if (routeResult.isErr())
+        return (0, monads_1.Err)(routeResult.unwrapErr());
+    const routeResponse = routeResult.unwrap();
+    if (!(0, xhr_1.isRouteSuccess)(routeResponse)) {
+        if (routeResponse.errno === xhr_1.ButterSwapErrorCode.InsufficientAmount) {
+            const minAmountCryptoBaseUnit = (0, utils_1.toBaseUnit)(routeResponse.minAmount, sellAsset.precision);
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({
+                minAmountCryptoBaseUnit,
+                assetId: sellAsset.assetId,
+            }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getTradeQuote] ${routeResponse.message}`,
+            code: (0, xhr_1.butterSwapErrorToTradeQuoteError)(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[getTradeQuote] No route found',
+            code: types_1.TradeQuoteError.NoRouteFound,
+        }));
+    }
+    // Call ButterSwap /swap API to get calldata and contract info
+    const buildTxResult = await (0, xhr_1.fetchTxData)({
+        hash: route.hash,
+        slippage,
+        from: sendAddress,
+        receiver: receiveAddress, // receiver (destination chain address)
+    });
+    if (buildTxResult.isErr())
+        return (0, monads_1.Err)(buildTxResult.unwrapErr());
+    const buildTxResponse = buildTxResult.unwrap();
+    if (!(0, xhr_1.isBuildTxSuccess)(buildTxResponse)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getTradeQuote] /swap failed: ${buildTxResponse.message}`,
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+    const buildTx = buildTxResponse.data[0];
+    if (!buildTx) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[getTradeQuote] No buildTx data returned',
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+    // Fee asset for network fees
+    const feeAsset = _deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(sellAsset.chainId)];
+    if (!feeAsset) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getTradeQuote] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Map gasFee.amount to networkFeeCryptoBaseUnit using fee asset precision
+    const networkFeeCryptoBaseUnit = (0, utils_1.toBaseUnit)((0, utils_1.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 = (0, utils_1.toBaseUnit)(outputAmount, buyAsset.precision);
+    const rate = (0, utils_2.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 !== caip_1.solanaChainId)
+            return (0, monads_1.Ok)(undefined);
+        const txData = buildTx.data.startsWith('0x') ? buildTx.data.slice(2) : buildTx.data;
+        const versionedTransaction = web3_js_1.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 web3_js_1.AddressLookupTableAccount({
+                key: new web3_js_1.PublicKey(info.key),
+                state: web3_js_1.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 = web3_js_1.TransactionMessage.decompile(versionedTransaction.message, {
+                addressLookupTableAccounts,
+            }).instructions;
+            return (0, monads_1.Ok)({
+                instructions,
+                addressLookupTableAddresses: addressLookupTableAccountKeys,
+            });
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[getTradeQuote] Error decompiling VersionedMessage: ${error}`,
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
+        }
+    })();
+    if (sellAsset.chainId === caip_1.solanaChainId && maybeSolanaTransactionMetadata?.isErr()) {
+        return (0, monads_1.Err)(maybeSolanaTransactionMetadata.unwrapErr());
+    }
+    const solanaTransactionMetadata = maybeSolanaTransactionMetadata?.unwrap();
+    const step = {
+        buyAmountBeforeFeesCryptoBaseUnit: (0, utils_1.toBaseUnit)(outputAmount, buyAsset.precision),
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: undefined,
+        },
+        rate,
+        source: types_1.SwapperName.ButterSwap,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        allowanceContract: route.contract ?? '0x0',
+        estimatedExecutionTimeMs: route.timeEstimated * 1000,
+        butterSwapTransactionMetadata: {
+            to: buildTx.to,
+            data: buildTx.data,
+            value: buildTx.value,
+            gasLimit: (0, utils_1.bnOrZero)(route.gasEstimatedTarget).toFixed(),
+        },
+        ...(solanaTransactionMetadata && {
+            solanaTransactionMetadata,
+        }),
+    };
+    const tradeQuote = {
+        id: route.hash,
+        rate,
+        receiveAddress,
+        affiliateBps,
+        isStreaming: false,
+        quoteOrRate: 'quote',
+        swapperName: types_1.SwapperName.ButterSwap,
+        slippageTolerancePercentageDecimal: slippageDecimal,
+        steps: [step],
+    };
+    return (0, monads_1.Ok)([tradeQuote]);
+};
+exports.getTradeQuote = getTradeQuote;

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

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

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

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

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

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