@shapeshiftoss/swapper 17.6.10 → 17.7.0

package/dist/esm/constants.js

@@ -15,8 +15,8 @@ import { chainflipSwapper } from './swappers/ChainflipSwapper/ChainflipSwapper.j
 import { chainflipApi } from './swappers/ChainflipSwapper/endpoints.js';
 import { cowSwapper } from './swappers/CowSwapper/CowSwapper.js';
 import { cowApi } from './swappers/CowSwapper/endpoints.js';
-import { jupiterApi } from './swappers/JupiterSwapper/endpoints.js';
-import { jupiterSwapper } from './swappers/JupiterSwapper/JupiterSwapper.js';
+import { debridgeSwapper } from './swappers/DebridgeSwapper/index.js';
+import { debridgeApi } from './swappers/DebridgeSwapper/endpoints.js';
 import { mayachainApi } from './swappers/MayachainSwapper/endpoints.js';
 import { mayachainSwapper } from './swappers/MayachainSwapper/MayachainSwapper.js';
 import { nearIntentsApi } from './swappers/NearIntentsSwapper/endpoints.js';
@@ -71,10 +71,6 @@ export const swappers = {
         ...chainflipSwapper,
         ...chainflipApi,
     },
-    [SwapperName.Jupiter]: {
-        ...jupiterSwapper,
-        ...jupiterApi,
-    },
     [SwapperName.Relay]: {
         ...relaySwapper,
         ...relayApi,
@@ -111,6 +107,10 @@ export const swappers = {
         ...acrossSwapper,
         ...acrossApi,
     },
+    [SwapperName.Debridge]: {
+        ...debridgeSwapper,
+        ...debridgeApi,
+    },
     [SwapperName.Test]: undefined,
 };
 const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002';
@@ -127,6 +127,8 @@ const DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005';
 // Starknet swaps can have more latency, so use higher default slippage
 const DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02';
 const DEFAULT_STONFI_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
+// deBridge API off-chain simulation overestimates output on some chains (e.g. SEI ~2.4%), so auto slippage (1%) is insufficient
+const DEFAULT_DEBRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0.03';
 export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
     if (swapperName === undefined)
         return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
@@ -147,12 +149,12 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             return DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.Chainflip:
             return DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE;
-        case SwapperName.Jupiter:
-            throw new Error('Default slippage not supported by Jupiter');
         case SwapperName.Relay:
             throw new Error('Default slippage not supported by Relay');
         case SwapperName.Across:
             throw new Error('Default slippage not supported by Across');
+        case SwapperName.Debridge:
+            return DEFAULT_DEBRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.ButterSwap:
             return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.NearIntents:
@@ -171,10 +173,9 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
 };
 export const isAutoSlippageSupportedBySwapper = (swapperName) => {
     switch (swapperName) {
-        case SwapperName.Jupiter:
-            return true;
         case SwapperName.Relay:
         case SwapperName.Across:
+        case SwapperName.Debridge:
             return true;
         default:
             return false;

package/dist/esm/cowswap-utils/constants.js

@@ -24,6 +24,9 @@ export const SUPPORTED_CHAIN_IDS = [
     KnownChainIds.AvalancheMainnet,
     KnownChainIds.PolygonMainnet,
     KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.PlasmaMainnet,
+    KnownChainIds.LineaMainnet,
+    KnownChainIds.InkMainnet,
 ];
 export const COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
 export const COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';

package/dist/esm/cowswap-utils/index.js

@@ -24,6 +24,12 @@ export const getCowNetwork = (chainId) => {
             return CowNetwork.Polygon;
         case KnownChainIds.BnbSmartChainMainnet:
             return CowNetwork.Bnb;
+        case KnownChainIds.PlasmaMainnet:
+            return CowNetwork.Plasma;
+        case KnownChainIds.LineaMainnet:
+            return CowNetwork.Linea;
+        case KnownChainIds.InkMainnet:
+            return CowNetwork.Ink;
         default:
             return;
     }

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
-export * from './swappers/JupiterSwapper/index.js';
+export * from './swappers/DebridgeSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';

package/dist/esm/index.js

@@ -9,7 +9,7 @@ export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
-export * from './swappers/JupiterSwapper/index.js';
+export * from './swappers/DebridgeSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';

package/dist/esm/solana-utils/getUnsignedSolanaTransaction.js

@@ -1,6 +1,8 @@
 import { bnOrZero } from '@shapeshiftoss/utils';
-import { COMPUTE_UNIT_MARGIN_MULTIPLIER } from '../swappers/JupiterSwapper/index.js';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+// Jupiter (and Relay which uses Jupiter under the hood) use 40% as a compute unit margin while
+// calculating them, some TX reverts without this. For stability purposes we add 60% margin.
+const COMPUTE_UNIT_MARGIN_MULTIPLIER = 1.6;
 export const getUnsignedSolanaTransaction = async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
     if (!isExecutableTradeQuote(tradeQuote))
         throw new Error('Unable to execute a trade rate quote');

package/dist/esm/swappers/AcrossSwapper/constant.js

@@ -1,7 +1,7 @@
-import { arbitrumChainId, baseChainId, blastChainId, bscChainId, ethChainId, hyperEvmChainId, inkChainId, lineaChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, solanaChainId, soneiumChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
+import { arbitrumChainId, baseChainId, blastChainId, bscChainId, ethChainId, hyperEvmChainId, inkChainId, lineaChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, scrollChainId, solanaChainId, soneiumChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, base, blast, bsc, hyperEvm, ink, linea, mainnet as ethereum, mode, monad, optimism, plasma, polygon, soneium, unichain, worldchain, zksync, } from 'viem/chains';
+import { arbitrum, base, blast, bsc, hyperEvm, ink, linea, mainnet as ethereum, mode, monad, optimism, plasma, polygon, scroll, soneium, unichain, worldchain, zksync, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { AcrossErrorCode } from './utils/types.js';
 export const chainIdToAcrossChainId = {
@@ -24,6 +24,8 @@ export const chainIdToAcrossChainId = {
     [soneiumChainId]: soneium.id,
     // Across uses a custom Solana chain ID
     [solanaChainId]: 34268394551451,
+    [scrollChainId]: scroll.id,
+    [megaethChainId]: 4326,
 };
 export const acrossChainIdToChainId = invert(chainIdToAcrossChainId);
 export const ACROSS_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToAcrossChainId);

package/dist/esm/swappers/AcrossSwapper/utils/getTrade.js

@@ -7,6 +7,7 @@ import axios from 'axios';
 import { zeroAddress } from 'viem';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { ACROSS_SOLANA_TOKEN_ADDRESS, acrossChainIdToChainId, acrossErrorCodeToTradeQuoteError, chainIdToAcrossChainId, DEFAULT_ACROSS_EVM_TOKEN_ADDRESS, DEFAULT_ACROSS_EVM_USER_ADDRESS, DEFAULT_ACROSS_SOLANA_USER_ADDRESS, } from '../constant.js';
 import { fetchAcrossTrade } from './fetchAcrossTrade.js';
@@ -178,7 +179,9 @@ export async function getTrade({ input, deps, }) {
         if (quote.swapTx.ecosystem !== 'svm')
             return Ok(undefined);
         try {
-            const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(Buffer.from(quote.swapTx.data, 'base64')));
+            const txBytes = Buffer.from(quote.swapTx.data, 'base64');
+            const isOversized = txBytes.length > 1232;
+            const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
             const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
             const addressLookupTableAccountKeys = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
             const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAccountKeys);
@@ -194,6 +197,7 @@ export async function getTrade({ input, deps, }) {
             return Ok({
                 instructions: instructionsWithoutComputeBudget,
                 addressLookupTableAddresses: addressLookupTableAccountKeys,
+                isOversized,
             });
         }
         catch (e) {
@@ -295,6 +299,16 @@ export async function getTrade({ input, deps, }) {
         estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
         acrossTransactionMetadata,
         solanaTransactionMetadata,
+        affiliateFee: appFee !== undefined && appFeeRecipient !== undefined
+            ? buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            })
+            : undefined,
     };
     const baseQuoteOrRate = {
         id: quote.id,

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

@@ -1,4 +1,5 @@
 import { getQuotes } from '@avnu/avnu-sdk';
+import { starknetChainId } from '@shapeshiftoss/caip';
 import { bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { validateAndParseAddress } from 'starknet';
@@ -6,6 +7,7 @@ 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';
@@ -55,7 +57,8 @@ export const getTradeQuote = async (input, deps) => {
             takerAddress: normalizedSendAddress,
             size: 1,
             integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
-            integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
+            integratorFeeRecipient: getTreasuryAddressFromChainId(starknetChainId),
+            integratorName: 'shapeshift',
         });
         if (!quotes || quotes.length === 0) {
             return Err(makeSwapErrorRight({
@@ -128,6 +131,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

@@ -6,6 +6,7 @@ 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';
@@ -105,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,
+                }),
             },
         ],
     });