@shapeshiftoss/swapper 17.6.9 → 17.6.11

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

@@ -1,11 +1,13 @@
 import { getQuotes } from '@avnu/avnu-sdk';
 import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { validateAndParseAddress } from 'starknet';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
 import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
 import { getTokenAddress } from '../utils/helpers.js';
 export const getTradeQuote = async (input, deps) => {
@@ -43,11 +45,15 @@ export const getTradeQuote = async (input, deps) => {
     try {
         const sellTokenAddress = getTokenAddress(sellAsset);
         const buyTokenAddress = getTokenAddress(buyAsset);
+        // Normalize addresses to ensure consistent format across quote and execution
+        // Starknet addresses can have different representations (with/without leading zeros)
+        const normalizedSendAddress = validateAndParseAddress(sendAddress);
+        const normalizedReceiveAddress = validateAndParseAddress(receiveAddress);
         const quotes = await getQuotes({
             sellTokenAddress,
             buyTokenAddress,
             sellAmount: BigInt(sellAmount),
-            takerAddress: sendAddress,
+            takerAddress: normalizedSendAddress,
             size: 1,
             integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
             integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
@@ -68,10 +74,10 @@ export const getTradeQuote = async (input, deps) => {
         const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
         const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
         const feeData = await sellAdapter.getFeeData({
-            to: receiveAddress,
+            to: normalizedReceiveAddress,
             value: sellAmount,
             chainSpecific: {
-                from: sendAddress,
+                from: normalizedSendAddress,
                 tokenContractAddress: sellTokenAddress,
             },
             sendMax: false,
@@ -96,7 +102,7 @@ export const getTradeQuote = async (input, deps) => {
             : {};
         const tradeQuote = {
             id: uuid(),
-            receiveAddress,
+            receiveAddress: normalizedReceiveAddress,
             affiliateBps,
             rate,
             slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
@@ -123,6 +129,14 @@ export const getTradeQuote = async (input, deps) => {
                         quoteId: bestQuote.quoteId,
                         routes: bestQuote.routes,
                     },
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    }),
                 },
             ],
         };

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

@@ -1,11 +1,13 @@
 import { getQuotes } from '@avnu/avnu-sdk';
 import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { validateAndParseAddress } from 'starknet';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
 import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
 import { getTokenAddress } from '../utils/helpers.js';
 export const getTradeRate = async (input, deps) => {
@@ -25,6 +27,9 @@ export const getTradeRate = async (input, deps) => {
     try {
         const sellTokenAddress = getTokenAddress(sellAsset);
         const buyTokenAddress = getTokenAddress(buyAsset);
+        // Normalize receive address if provided (for fee estimation)
+        // Rate quotes may not have a receive address, so this is optional
+        const normalizedReceiveAddress = receiveAddress ? validateAndParseAddress(receiveAddress) : '';
         const quotes = await getQuotes({
             sellTokenAddress,
             buyTokenAddress,
@@ -50,10 +55,10 @@ export const getTradeRate = async (input, deps) => {
         const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
         // For rate quotes, use receiveAddress as a dummy from/to for fee estimation
         const feeData = await sellAdapter.getFeeData({
-            to: receiveAddress ?? '',
+            to: normalizedReceiveAddress,
             value: sellAmount,
             chainSpecific: {
-                from: receiveAddress ?? '',
+                from: normalizedReceiveAddress,
                 tokenContractAddress: sellTokenAddress,
             },
             sendMax: false,
@@ -78,7 +83,7 @@ export const getTradeRate = async (input, deps) => {
             : {};
         const tradeRate = {
             id: uuid(),
-            receiveAddress,
+            receiveAddress: normalizedReceiveAddress || receiveAddress,
             affiliateBps,
             rate,
             slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
@@ -101,6 +106,14 @@ export const getTradeRate = async (input, deps) => {
                     sellAsset,
                     source: SwapperName.Avnu,
                     estimatedExecutionTimeMs: undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    }),
                 },
             ],
         };

package/dist/esm/swappers/BebopSwapper/BebopSwapper.js

@@ -1,4 +1,6 @@
 import { executeEvmTransaction } from '../../utils.js';
+import { executeSolanaMessage } from './executeSolanaMessage.js';
 export const bebopSwapper = {
     executeEvmTransaction,
+    executeSolanaMessage,
 };

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

@@ -1,15 +1,27 @@
+import { solanaChainId } from '@shapeshiftoss/caip';
 import { evm } from '@shapeshiftoss/chain-adapters';
 import BigNumber from 'bignumber.js';
 import { fromHex } from 'viem';
-import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkEvmSwapStatus, checkSolanaSwapStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { getBebopSolanaTradeQuote } from './getBebopSolanaTradeQuote/getBebopSolanaTradeQuote.js';
+import { getBebopSolanaTradeRate } from './getBebopSolanaTradeRate/getBebopSolanaTradeRate.js';
 import { getBebopTradeQuote } from './getBebopTradeQuote/getBebopTradeQuote.js';
 import { getBebopTradeRate } from './getBebopTradeRate/getBebopTradeRate.js';
+import { isSolanaChainId } from './utils/helpers/helpers.js';
 export const bebopApi = {
     getTradeQuote: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
+        if (isSolanaChainId(input.sellAsset.chainId)) {
+            const tradeQuoteResult = await getBebopSolanaTradeQuote(input, assetsById, config.VITE_BEBOP_API_KEY);
+            return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+        }
         const tradeQuoteResult = await getBebopTradeQuote(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
         return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
     },
     getTradeRate: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
+        if (isSolanaChainId(input.sellAsset.chainId)) {
+            const tradeRateResult = await getBebopSolanaTradeRate(input, assetsById, config.VITE_BEBOP_API_KEY);
+            return tradeRateResult.map(tradeRate => [tradeRate]);
+        }
         const tradeRateResult = await getBebopTradeRate(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
         return tradeRateResult.map(tradeRate => [tradeRate]);
     },
@@ -34,10 +46,22 @@ export const bebopApi = {
             to,
             value,
             ...feeData,
-            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding
             gasLimit: BigNumber.max(feeData.gasLimit, gas).toFixed(),
         });
     },
+    getUnsignedSolanaMessage: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { bebopSolanaSerializedTx, bebopQuoteId } = step;
+        if (!bebopSolanaSerializedTx || !bebopQuoteId) {
+            throw new Error('Bebop Solana transaction metadata is required');
+        }
+        return Promise.resolve({
+            serializedTx: bebopSolanaSerializedTx,
+            quoteId: bebopQuoteId,
+        });
+    },
     getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
@@ -51,5 +75,14 @@ export const bebopApi = {
         const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
         return feeData.networkFeeCryptoBaseUnit;
     },
-    checkTradeStatus: checkEvmSwapStatus,
+    checkTradeStatus: input => {
+        if (input.chainId === solanaChainId) {
+            return checkSolanaSwapStatus({
+                txHash: input.txHash,
+                address: input.address,
+                assertGetSolanaChainAdapter: input.assertGetSolanaChainAdapter,
+            });
+        }
+        return checkEvmSwapStatus(input);
+    },
 };

package/dist/esm/swappers/BebopSwapper/executeSolanaMessage.d.ts

@@ -0,0 +1,2 @@
+import type { SolanaMessageExecutionProps, SolanaMessageToSign, SwapperConfig } from '../../types.js';
+export declare const executeSolanaMessage: (messageData: SolanaMessageToSign, { signSerializedTransaction }: SolanaMessageExecutionProps, config: SwapperConfig) => Promise<string>;

package/dist/esm/swappers/BebopSwapper/executeSolanaMessage.js

@@ -0,0 +1,40 @@
+import bs58 from 'bs58';
+import { bebopServiceFactory } from './utils/bebopService.js';
+export const executeSolanaMessage = async (messageData, { signSerializedTransaction }, config) => {
+    const { serializedTx, quoteId } = messageData;
+    if (!serializedTx || !quoteId) {
+        throw new Error('Missing serializedTx or quoteId in message data');
+    }
+    const signatures = await signSerializedTransaction(serializedTx);
+    if (!signatures.length) {
+        throw new Error('No signatures returned from wallet');
+    }
+    // Find the actual non-zero user signature (skip empty placeholder slots from co-signers)
+    const nonZeroSigIndex = signatures.findIndex(sig => {
+        const bytes = Buffer.from(sig, 'base64');
+        return !bytes.every(b => b === 0);
+    });
+    if (nonZeroSigIndex === -1) {
+        throw new Error('No non-zero signatures found after signing');
+    }
+    const userSignatureBase64 = signatures[nonZeroSigIndex];
+    const userSignatureBytes = Buffer.from(userSignatureBase64, 'base64');
+    const userSignatureBase58 = bs58.encode(userSignatureBytes);
+    const bebopService = bebopServiceFactory({ apiKey: config.VITE_BEBOP_API_KEY });
+    const maybeOrderResponse = await bebopService.post('https://api.bebop.xyz/pmm/solana/v3/order', {
+        quote_id: quoteId,
+        signature: userSignatureBase58,
+    });
+    if (maybeOrderResponse.isErr()) {
+        const error = maybeOrderResponse.unwrapErr();
+        throw new Error(`Bebop order submission failed: ${error.cause ?? error.message}`);
+    }
+    const { data: orderResponse } = maybeOrderResponse.unwrap();
+    if (orderResponse.error) {
+        throw new Error(`Bebop order failed: ${orderResponse.error.message} (code ${orderResponse.error.errorCode})`);
+    }
+    if (!orderResponse.txHash) {
+        throw new Error(`Bebop order response missing txHash: ${JSON.stringify(orderResponse)}`);
+    }
+    return orderResponse.txHash;
+};

package/dist/esm/swappers/BebopSwapper/getBebopSolanaTradeQuote/getBebopSolanaTradeQuote.d.ts

@@ -0,0 +1,4 @@
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetSolanaTradeQuoteInput, SwapErrorRight, TradeQuote } from '../../../types.js';
+export declare function getBebopSolanaTradeQuote(input: GetSolanaTradeQuoteInput, _assetsById: AssetsByIdPartial, apiKey: string): Promise<Result<TradeQuote, SwapErrorRight>>;

package/dist/esm/swappers/BebopSwapper/getBebopSolanaTradeQuote/getBebopSolanaTradeQuote.js

@@ -0,0 +1,87 @@
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { fetchBebopSolanaQuote } from '../utils/fetchFromBebop.js';
+import { assertValidTrade, calculateRate, isBebopSolanaTxSafe } from '../utils/helpers/helpers.js';
+export async function getBebopSolanaTradeQuote(input, _assetsById, apiKey) {
+    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const takerAddress = sendAddress || receiveAddress;
+    if (!takerAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'Cannot execute quote without a wallet address',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
+    const maybeBebopQuoteResponse = await fetchBebopSolanaQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress,
+        receiverAddress: receiveAddress ?? takerAddress,
+        slippageTolerancePercentageDecimal,
+        affiliateBps,
+        apiKey,
+    });
+    if (maybeBebopQuoteResponse.isErr())
+        return Err(maybeBebopQuoteResponse.unwrapErr());
+    const bebopQuoteResponse = maybeBebopQuoteResponse.unwrap();
+    const sellTokenAddress = Object.keys(bebopQuoteResponse.sellTokens)[0];
+    const buyTokenAddress = Object.keys(bebopQuoteResponse.buyTokens)[0];
+    if (!sellTokenAddress || !buyTokenAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    if (bebopQuoteResponse.solana_tx &&
+        !isBebopSolanaTxSafe(bebopQuoteResponse.solana_tx, takerAddress)) {
+        return Err(makeSwapErrorRight({
+            message: 'Bebop signer index mismatch - taker not at expected position',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const sellAmount = bebopQuoteResponse.sellTokens[sellTokenAddress].amount;
+    const buyAmount = bebopQuoteResponse.buyTokens[buyTokenAddress].amount;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = bebopQuoteResponse.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    // Bebop Solana is gasless - Bebop pays the network fees via co-signing
+    const networkFeeCryptoBaseUnit = '0';
+    return Ok({
+        id: uuid(),
+        quoteOrRate: 'quote',
+        receiveAddress: receiveAddress ?? takerAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        rate,
+        swapperName: SwapperName.Bebop,
+        steps: [
+            {
+                estimatedExecutionTimeMs: 0,
+                allowanceContract: '0x0',
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                rate,
+                feeData: {
+                    protocolFees: {},
+                    networkFeeCryptoBaseUnit,
+                },
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                source: SwapperName.Bebop,
+                bebopSolanaSerializedTx: bebopQuoteResponse.solana_tx,
+                bebopQuoteId: bebopQuoteResponse.quoteId,
+            },
+        ],
+    });
+}

package/dist/esm/swappers/BebopSwapper/getBebopSolanaTradeRate/getBebopSolanaTradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetSolanaTradeRateInput, SwapErrorRight, TradeRate } from '../../../types.js';
+export declare function getBebopSolanaTradeRate(input: GetSolanaTradeRateInput, _assetsById: AssetsByIdPartial, apiKey: string): Promise<Result<TradeRate, SwapErrorRight>>;

package/dist/esm/swappers/BebopSwapper/getBebopSolanaTradeRate/getBebopSolanaTradeRate.js

@@ -0,0 +1,84 @@
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { fetchBebopSolanaPrice } from '../utils/fetchFromBebop.js';
+import { assertValidTrade, calculateRate, isBebopSolanaTxSafe } from '../utils/helpers/helpers.js';
+export async function getBebopSolanaTradeRate(input, _assetsById, apiKey) {
+    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
+    const maybeBebopPriceResponse = await fetchBebopSolanaPrice({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        receiveAddress,
+        affiliateBps,
+        apiKey,
+    });
+    if (maybeBebopPriceResponse.isErr())
+        return Err(maybeBebopPriceResponse.unwrapErr());
+    const bebopPriceResponse = maybeBebopPriceResponse.unwrap();
+    const sellTokenAddress = Object.keys(bebopPriceResponse.sellTokens)[0];
+    const buyTokenAddress = Object.keys(bebopPriceResponse.buyTokens)[0];
+    if (!sellTokenAddress || !buyTokenAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    if (bebopPriceResponse.solana_tx) {
+        if (!receiveAddress) {
+            return Err(makeSwapErrorRight({
+                message: 'Cannot validate Bebop Solana tx without a taker address',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        if (!isBebopSolanaTxSafe(bebopPriceResponse.solana_tx, receiveAddress)) {
+            return Err(makeSwapErrorRight({
+                message: 'Bebop signer index mismatch - taker not at expected position',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+    }
+    const sellAmount = bebopPriceResponse.sellTokens[sellTokenAddress].amount;
+    const buyAmount = bebopPriceResponse.buyTokens[buyTokenAddress].amount;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = bebopPriceResponse.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    // Bebop Solana is gasless - Bebop pays the network fees via co-signing
+    const networkFeeCryptoBaseUnit = '0';
+    return Ok({
+        id: uuid(),
+        quoteOrRate: 'rate',
+        accountNumber: undefined,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        rate,
+        swapperName: SwapperName.Bebop,
+        steps: [
+            {
+                estimatedExecutionTimeMs: 0,
+                allowanceContract: '0x0',
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                rate,
+                feeData: {
+                    protocolFees: {},
+                    networkFeeCryptoBaseUnit,
+                },
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                source: SwapperName.Bebop,
+            },
+        ],
+    });
+}

package/dist/esm/swappers/BebopSwapper/getBebopTradeQuote/getBebopTradeQuote.js

@@ -6,6 +6,7 @@ import { isAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { BEBOP_DUMMY_ADDRESS } from '../types.js';
 import { fetchBebopQuote } from '../utils/fetchFromBebop.js';
@@ -99,6 +100,15 @@ export async function getBebopTradeQuote(input, assertGetEvmChainAdapter, _asset
                     sellAmountIncludingProtocolFeesCryptoBaseUnit,
                     source: SwapperName.Bebop,
                     bebopTransactionMetadata: transactionMetadata,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         });

package/dist/esm/swappers/BebopSwapper/getBebopTradeRate/getBebopTradeRate.js

@@ -6,6 +6,7 @@ import { isAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { fetchBebopPrice } from '../utils/fetchFromBebop.js';
 import { assertValidTrade, calculateRate } from '../utils/helpers/helpers.js';
@@ -82,6 +83,15 @@ export async function getBebopTradeRate(input, assertGetEvmChainAdapter, _assets
                 buyAmountAfterFeesCryptoBaseUnit,
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 source: SwapperName.Bebop,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                }),
             },
         ],
     });

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

@@ -1,6 +1,7 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 import type { Address, Hex } from 'viem';
-export declare const bebopSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet];
+export declare const bebopSupportedEvmChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet];
+export declare const bebopSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.SolanaMainnet];
 export type BebopSupportedChainId = (typeof bebopSupportedChainIds)[number];
 export type BebopQuoteRoute = {
     type: string;
@@ -87,3 +88,50 @@ export type BebopQuoteResponse = {
 export declare const chainIdToBebopChain: Record<BebopSupportedChainId, string>;
 export declare const BEBOP_NATIVE_MARKER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 export declare const BEBOP_DUMMY_ADDRESS: `0x${string}`;
+export declare const BEBOP_SOLANA_DUMMY_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export type BebopSolanaQuoteResponse = {
+    requestId: string;
+    type: string;
+    status: 'QUOTE_SUCCESS' | 'QUOTE_INDIC_ROUTE';
+    quoteId: string;
+    chainId: number;
+    approvalType: string;
+    nativeToken: string;
+    taker: string;
+    receiver: string;
+    expiry: number;
+    slippage: number;
+    gasFee: {
+        native: string;
+        usd: number;
+    };
+    buyTokens: Record<string, {
+        amount: string;
+        decimals: number;
+        priceUsd: number;
+        symbol: string;
+        minimumAmount: string;
+        price: number;
+        priceBeforeFee: number;
+        amountBeforeFee: string;
+        deltaFromExpected: number;
+    }>;
+    sellTokens: Record<string, {
+        amount: string;
+        decimals: number;
+        priceUsd: number;
+        symbol: string;
+        price: number;
+        priceBeforeFee: number;
+    }>;
+    settlementAddress: string;
+    approvalTarget: string;
+    requiredSignatures: string[];
+    priceImpact: number;
+    warnings: string[];
+    solana_tx: string;
+    blockhash: string;
+    makers: string[];
+    partnerFee?: Record<string, string>;
+    protocolFee?: Record<string, string>;
+};

package/dist/esm/swappers/BebopSwapper/types.js

@@ -1,5 +1,5 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-export const bebopSupportedChainIds = [
+export const bebopSupportedEvmChainIds = [
     KnownChainIds.EthereumMainnet,
     KnownChainIds.PolygonMainnet,
     KnownChainIds.ArbitrumMainnet,
@@ -8,6 +8,10 @@ export const bebopSupportedChainIds = [
     KnownChainIds.OptimismMainnet,
     KnownChainIds.BnbSmartChainMainnet,
 ];
+export const bebopSupportedChainIds = [
+    ...bebopSupportedEvmChainIds,
+    KnownChainIds.SolanaMainnet,
+];
 export const chainIdToBebopChain = {
     [KnownChainIds.EthereumMainnet]: 'ethereum',
     [KnownChainIds.PolygonMainnet]: 'polygon',
@@ -16,9 +20,12 @@ export const chainIdToBebopChain = {
     [KnownChainIds.AvalancheMainnet]: 'avalanche',
     [KnownChainIds.OptimismMainnet]: 'optimism',
     [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.SolanaMainnet]: 'solana',
 };
 export const BEBOP_NATIVE_MARKER = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
 // Dummy address used for rate quotes when no wallet is connected.
 // This is Vitalik's address, same as what Bebop's own UI uses for price-only quotes.
 // MUST NEVER be used for executable quote transactions.
 export const BEBOP_DUMMY_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+// Solana dummy address for rate quotes - uses the Token Program address which cannot be a real wallet
+export const BEBOP_SOLANA_DUMMY_ADDRESS = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';

package/dist/esm/swappers/BebopSwapper/utils/fetchFromBebop.d.ts

@@ -2,7 +2,7 @@ import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { Address } from 'viem';
 import type { SwapErrorRight } from '../../../types.js';
-import type { BebopQuoteResponse } from '../types.js';
+import type { BebopQuoteResponse, BebopSolanaQuoteResponse } from '../types.js';
 export declare const fetchBebopQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }: {
     buyAsset: Asset;
     sellAsset: Asset;
@@ -21,3 +21,21 @@ export declare const fetchBebopPrice: ({ buyAsset, sellAsset, sellAmountIncludin
     affiliateBps?: string | undefined;
     apiKey: string;
 }) => Promise<Result<BebopQuoteResponse, SwapErrorRight>>;
+export declare const fetchBebopSolanaQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    takerAddress: string;
+    receiverAddress: string;
+    slippageTolerancePercentageDecimal: string;
+    affiliateBps?: string | undefined;
+    apiKey: string;
+}) => Promise<Result<BebopSolanaQuoteResponse, SwapErrorRight>>;
+export declare const fetchBebopSolanaPrice: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    receiveAddress: string | undefined;
+    affiliateBps?: string | undefined;
+    apiKey: string;
+}) => Promise<Result<BebopSolanaQuoteResponse, SwapErrorRight>>;