@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -1,78 +1,35 @@
-import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } from '@shapeshiftoss/utils';
+import { tronChainId } from '@shapeshiftoss/caip';
+import { convertDecimalPercentageToBasisPoints } 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 { buildAffiliateFee } from '../../utils/affiliateFee.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 &&
-        sellAsset.chainId !== tronChainId) {
-        return Err(makeSwapErrorRight({
-            message: `Unsupported chain`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    // TODO: Debug why same-chain Tron swaps revert (swapAndCall method works on EVM but 0 successful on Tron)
-    if (!sendAddress) {
-        return Err(makeSwapErrorRight({
-            message: '[getTradeQuote] sendAddress is required for ButterSwap',
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
+import { getButterSwapStepData } from '../utils/getButterSwapStepData.js';
+import { getButterSwapTradeContext } from '../utils/getButterSwapTradeContext.js';
+import { fetchTxData, isBuildTxSuccess } from '../xhr.js';
+// TODO: Debug why same-chain Tron swaps revert (swapAndCall method works on EVM but 0 successful on Tron)
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, receiveAddress, accountNumber, slippageTolerancePercentageDecimal } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress } = maybeAddresses.unwrap();
     const slippageDecimal = slippageTolerancePercentageDecimal ??
         getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ButterSwap);
-    const slippage = convertDecimalPercentageToBasisPoints(slippageDecimal).toString();
-    // Call ButterSwap /route API
-    const routeResult = await getButterRoute({
-        sellAsset,
-        buyAsset,
-        sellAmountCryptoPrecision: BigAmount.fromBaseUnit({
-            value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            precision: sellAsset.precision,
-        }).toPrecision(),
-        slippage,
-        affiliate: makeButterSwapAffiliate(affiliateBps),
+    const maybeContext = await getButterSwapTradeContext({
+        input,
+        deps,
+        slippageTolerancePercentageDecimal: slippageDecimal,
     });
-    if (routeResult.isErr())
-        return Err(routeResult.unwrapErr());
-    const routeResponse = routeResult.unwrap();
-    if (!isRouteSuccess(routeResponse)) {
-        if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
-            const minAmountCryptoBaseUnit = BigAmount.fromPrecision({
-                value: routeResponse.minAmount,
-                precision: sellAsset.precision,
-            }).toBaseUnit();
-            return Err(createTradeAmountTooSmallErr({
-                minAmountCryptoBaseUnit,
-                assetId: sellAsset.assetId,
-            }));
-        }
-        return Err(makeSwapErrorRight({
-            message: `[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
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, route, stepDataArgs } = maybeContext.unwrap();
     const buildTxResult = await fetchTxData({
         hash: route.hash,
-        slippage,
+        slippage: convertDecimalPercentageToBasisPoints(slippageDecimal).toString(),
         from: sendAddress,
-        receiver: receiveAddress, // receiver (destination chain address)
+        receiver: receiveAddress,
     });
     if (buildTxResult.isErr())
         return Err(buildTxResult.unwrapErr());
@@ -90,127 +47,32 @@ export const getTradeQuote = async (input, _deps) => {
             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 = BigAmount.fromPrecision({
-        value: bnOrZero(route.gasFee?.amount),
-        precision: feeAsset.precision,
-    }).toBaseUnit();
-    // 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 = BigAmount.fromPrecision({
-        value: outputAmount,
-        precision: buyAsset.precision,
-    }).toBaseUnit();
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-        sellAsset,
-        buyAsset,
+    const maybeStepData = await getButterSwapStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        buildTx,
+        from: sendAddress,
     });
-    // 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 txBytes = Buffer.from(txData, 'hex');
-        // Solana transactions are limited to 1232 bytes. If Butter returns a larger tx,
-        // we need to split it into a Jito bundle (2 txs with tip in the last one).
-        const SOLANA_TX_SIZE_LIMIT = 1232;
-        const isOversized = txBytes.length > SOLANA_TX_SIZE_LIMIT;
-        const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
-        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,
-                isOversized,
-            });
-        }
-        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: BigAmount.fromPrecision({
-            value: outputAmount,
-            precision: buyAsset.precision,
-        }).toBaseUnit(),
-        buyAmountAfterFeesCryptoBaseUnit,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        feeData: {
-            networkFeeCryptoBaseUnit,
-            protocolFees: undefined,
-        },
-        rate,
-        source: SwapperName.ButterSwap,
-        buyAsset,
-        sellAsset,
-        accountNumber,
-        allowanceContract: sellAsset.chainId === tronChainId ? buildTx.to : route.contract ?? '0x0',
-        estimatedExecutionTimeMs: route.timeEstimated * 1000,
-        butterSwapTransactionMetadata: {
-            to: buildTx.to,
-            data: buildTx.data,
-            value: buildTx.value,
-            gasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
-            method: buildTx.method,
-            args: buildTx.args,
-            memo: buildTx.memo,
-        },
-        ...(solanaTransactionMetadata && {
-            solanaTransactionMetadata,
-        }),
-        affiliateFee: buildAffiliateFee({
-            strategy: 'buy_asset',
-            affiliateBps,
-            sellAsset,
-            buyAsset,
-            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            isEstimate: true,
-        }),
-    };
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit, transactionData, butterSwapTransactionMetadata } = maybeStepData.unwrap();
     const tradeQuote = {
-        id: route.hash,
-        rate,
-        receiveAddress,
-        affiliateBps,
-        isStreaming: false,
+        ...tradeCommon,
         quoteOrRate: 'quote',
-        swapperName: SwapperName.ButterSwap,
-        slippageTolerancePercentageDecimal: slippageDecimal,
-        steps: [step],
+        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                // Tron exec still builds from legacy metadata whose spender is the buildTx target
+                allowanceContract: sellAsset.chainId === tronChainId ? buildTx.to : stepCommon.allowanceContract,
+                transactionData,
+                butterSwapTransactionMetadata,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
     return Ok([tradeQuote]);
 };

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

@@ -1,6 +1,7 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
 import { Ok } from '@sniptt/monads';
 import { describe, expect, it, vi } from 'vitest';
-import { ETH, USDC_MAINNET, WETH } from '../../utils/test-data/assets.js';
+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', () => ({
@@ -21,12 +22,30 @@ vi.mock('../xhr', () => ({
     isRouteSuccess: () => true,
     isBuildTxSuccess: () => true,
 }));
+// The override path reads live chain state - resolve to no override so estimation exercises the
+// mocked adapter
+vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vi.fn().mockResolvedValue(undefined),
+}));
+const mockEvmChainAdapter = {
+    getGasFeeData: () => Promise.resolve({
+        average: {
+            gasPrice: '1000000000',
+            maxFeePerGas: '2000000000',
+            maxPriorityFeePerGas: '1000000000',
+        },
+    }),
+    getFeeData: () => Promise.resolve({
+        average: { chainSpecific: { gasLimit: '500000', gasPrice: '1000000000' } },
+    }),
+};
 describe('getTradeQuote', () => {
     it('should return a trade quote', async () => {
         const deps = {
             assetsById: { [ETH.assetId]: ETH },
             assertGetChainAdapter: () => vi.fn(),
-            assertGetEvmChainAdapter: () => vi.fn(),
+            assertGetEvmChainAdapter: () => mockEvmChainAdapter,
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),
@@ -51,13 +70,23 @@ describe('getTradeQuote', () => {
             affiliateBps: '0',
             allowMultiHop: true,
             quoteOrRate: 'quote',
+            chainId: KnownChainIds.EthereumMainnet,
+            supportsEIP1559: false,
         };
         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');
+        // The built swap tx is what distinguishes a quote from a rate - see
+        // getButterSwapStepData.test.ts for the per-namespace build and fee behaviour
+        expect(tradeQuote[0].steps[0].transactionData).toEqual({
+            type: 'evm',
+            chainId: 1,
+            to: '0xContractAddress',
+            data: '0xCalldata',
+            value: '0',
+            gasLimit: '600000',
+        });
+        // The route contract, since this is not the tron path that spends via the buildTx target
+        expect(tradeQuote[0].steps[0].allowanceContract).toBe('0xEE030ec6F4307411607E55aCD08e628Ae6655B86');
     });
 });

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

@@ -1,3 +1,4 @@
 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>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { ButterSwapTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: ButterSwapTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,132 +1,34 @@
-import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } 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 { buildAffiliateFee } from '../../utils/affiliateFee.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 &&
-        sellAsset.chainId !== tronChainId) {
-        return Err(makeSwapErrorRight({
-            message: `Unsupported chain`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    const amount = BigAmount.fromBaseUnit({
-        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        precision: sellAsset.precision,
-    }).toPrecision();
-    const feeAssetId = chainIdToFeeAssetId(sellAsset.chainId);
+import { SwapperName } from '../../../types.js';
+import { getButterSwapStepData } from '../utils/getButterSwapStepData.js';
+import { getButterSwapTradeContext } from '../utils/getButterSwapTradeContext.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
     const slippageTolerancePercentageDecimal = getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ButterSwap);
-    const slippage = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toString();
-    const result = await getButterRoute({
-        sellAsset,
-        buyAsset,
-        sellAmountCryptoPrecision: 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 = BigAmount.fromPrecision({
-                value: routeResponse.minAmount,
-                precision: sellAsset.precision,
-            }).toBaseUnit();
-            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 = BigAmount.fromPrecision({
-        value: outputAmount,
-        precision: buyAsset.precision,
-    }).toBaseUnit();
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-        sellAsset,
-        buyAsset,
+    const maybeContext = await getButterSwapTradeContext({
+        input,
+        deps,
+        slippageTolerancePercentageDecimal,
     });
-    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)
-        ? BigAmount.fromPrecision({
-            value: route.gasFee.amount,
-            precision: feeAsset.precision,
-        }).toBaseUnit()
-        : '0';
-    // Always a single step
-    const step = {
-        rate,
-        buyAmountBeforeFeesCryptoBaseUnit: BigAmount.fromPrecision({
-            value: outputAmount,
-            precision: buyAsset.precision,
-        }).toBaseUnit(),
-        buyAmountAfterFeesCryptoBaseUnit,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        feeData: {
-            networkFeeCryptoBaseUnit,
-            protocolFees: undefined,
-        },
-        source: SwapperName.ButterSwap,
-        buyAsset,
-        sellAsset,
-        accountNumber,
-        allowanceContract: route.contract ?? '0x0',
-        estimatedExecutionTimeMs: route.timeEstimated * 1000,
-        affiliateFee: buildAffiliateFee({
-            strategy: 'buy_asset',
-            affiliateBps,
-            sellAsset,
-            buyAsset,
-            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            isEstimate: true,
-        }),
-    };
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getButterSwapStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
     const tradeRate = {
-        id: route.hash,
-        rate,
-        swapperName: SwapperName.ButterSwap,
-        receiveAddress,
-        affiliateBps,
-        slippageTolerancePercentageDecimal,
+        ...tradeCommon,
         quoteOrRate: 'rate',
-        steps: [step],
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
     return Ok([tradeRate]);
 };

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

@@ -2,7 +2,7 @@ import { KnownChainIds } from '@shapeshiftoss/types';
 import { bn } from '@shapeshiftoss/utils';
 import { Ok } from '@sniptt/monads';
 import { describe, expect, it, vi } from 'vitest';
-import { BTC, ETH, USDC_MAINNET, WETH } from '../../utils/test-data/assets.js';
+import { 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';
@@ -12,12 +12,21 @@ vi.mock('../utils/butterSwapService', () => ({
         get: vi.fn(),
     },
 }));
+const mockEvmChainAdapter = {
+    getGasFeeData: () => Promise.resolve({
+        average: {
+            gasPrice: '1000000000',
+            maxFeePerGas: '2000000000',
+            maxPriorityFeePerGas: '1000000000',
+        },
+    }),
+};
 describe('getTradeRate', () => {
     it('should return a trade rate', async () => {
         const deps = {
             assetsById: { [ETH.assetId]: ETH },
             assertGetChainAdapter: () => vi.fn(),
-            assertGetEvmChainAdapter: () => vi.fn(),
+            assertGetEvmChainAdapter: () => mockEvmChainAdapter,
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),
@@ -54,7 +63,7 @@ describe('getTradeRate', () => {
         const deps = {
             assetsById: { [ETH.assetId]: ETH, [BTC.assetId]: BTC },
             assertGetChainAdapter: () => vi.fn(),
-            assertGetEvmChainAdapter: () => vi.fn(),
+            assertGetEvmChainAdapter: () => mockEvmChainAdapter,
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),

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

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

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

@@ -1,12 +1,9 @@
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 5 * 1000; // 5 seconds
 const cachedUrls = [];
 const axiosConfig = {
     timeout: 10000,
-    headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    },
+    headers: { Accept: 'application/json' },
     baseURL: 'https://bs-app-api.chainservice.io',
 };
 const butterHistoryServiceBase = createCache(maxAge, cachedUrls, axiosConfig);

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

@@ -1,12 +1,9 @@
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 5 * 1000; // 5 seconds
 const cachedUrls = [];
 const axiosConfig = {
     timeout: 10000,
-    headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    },
+    headers: { Accept: 'application/json' },
     baseURL: 'https://bs-router-v3.chainservice.io',
 };
 const butterServiceBase = createCache(maxAge, cachedUrls, axiosConfig);

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

@@ -1,6 +1,8 @@
+import { bnOrZero } from '@shapeshiftoss/utils';
 const BUTTERSWAP_AFFILIATE = 'shapeshift';
+// Format is `<nickname>[:rate]`, where rate is in basis points (e.g. `shapeshift:60` = 0.6%).
 export const makeButterSwapAffiliate = (affiliateBps) => {
-    if (!BUTTERSWAP_AFFILIATE)
+    if (bnOrZero(affiliateBps).lte(0))
         return undefined;
     return `${BUTTERSWAP_AFFILIATE}:${affiliateBps}`;
 };

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

@@ -0,0 +1,32 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
+import type { BuildTxSuccessItem, ButterSwapTransactionMetadata, RouteSuccessItem } from '../types.js';
+export declare const BUTTERSWAP_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
+type BaseArgs = {
+    route: RouteSuccessItem;
+    feeAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+};
+export type GetButterSwapStepDataArgs = StepDataArgs<BaseArgs, {
+    buildTx?: undefined;
+}, {
+    buildTx: BuildTxSuccessItem;
+}>;
+type ButterSwapRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type ButterSwapQuoteStepData = {
+    transactionData?: TxBuildData;
+    butterSwapTransactionMetadata?: ButterSwapTransactionMetadata;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getButterSwapStepData(args: Extract<GetButterSwapStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<ButterSwapRateStepData, SwapErrorRight>>;
+export declare function getButterSwapStepData(args: Extract<GetButterSwapStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<ButterSwapQuoteStepData, SwapErrorRight>>;
+export {};