@shapeshiftoss/swapper 17.6.10 → 17.6.11

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>>;

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

@@ -3,9 +3,9 @@ import { Err, Ok } from '@sniptt/monads';
 import { getAddress } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
-import { BEBOP_DUMMY_ADDRESS, chainIdToBebopChain } from '../types.js';
+import { BEBOP_DUMMY_ADDRESS, BEBOP_SOLANA_DUMMY_ADDRESS, chainIdToBebopChain } from '../types.js';
 import { bebopServiceFactory } from './bebopService.js';
-import { assetIdToBebopToken } from './helpers/helpers.js';
+import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers/helpers.js';
 export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
         const sellToken = assetIdToBebopToken(sellAsset.assetId);
@@ -86,3 +86,86 @@ export const fetchBebopPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtoc
         apiKey,
     });
 };
+export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
+    try {
+        const sellToken = assetIdToBebopSolanaToken(sellAsset.assetId);
+        const buyToken = assetIdToBebopSolanaToken(buyAsset.assetId);
+        const sellAmountFormatted = bn(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0);
+        const slippagePercentage = bn(slippageTolerancePercentageDecimal ?? 0.003)
+            .times(100)
+            .toNumber();
+        const url = 'https://api.bebop.xyz/pmm/solana/v3/quote';
+        const params = new URLSearchParams({
+            sell_tokens: sellToken,
+            buy_tokens: buyToken,
+            sell_amounts: sellAmountFormatted,
+            taker_address: takerAddress,
+            receiver_address: receiverAddress,
+            slippage: slippagePercentage.toString(),
+            approval_type: 'Standard',
+            skip_validation: 'false',
+            gasless: 'true',
+            source: 'shapeshift',
+        });
+        if (affiliateBps && affiliateBps !== '0') {
+            params.set('fee', affiliateBps);
+        }
+        const bebopService = bebopServiceFactory({ apiKey });
+        const maybeResponse = await bebopService.get(`${url}?${params}`);
+        if (maybeResponse.isErr()) {
+            const err = maybeResponse.unwrapErr();
+            return Err(makeSwapErrorRight({
+                message: 'Failed to fetch quote from Bebop Solana',
+                cause: err.cause,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const response = maybeResponse.unwrap();
+        if (response.data.status !== 'QUOTE_SUCCESS') {
+            return Err(makeSwapErrorRight({
+                message: `Bebop Solana quote not executable: ${response.data.status}`,
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        if (!response.data.solana_tx) {
+            return Err(makeSwapErrorRight({
+                message: 'Missing solana_tx in response',
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        // Reject routes containing ANY AMM/CLMM makers - these produce malformed txs
+        // (wrong signature count in wire format) and require pre-existing ATAs that
+        // Bebop's gasless co-signed flow can't create. This includes mixed routes
+        // like ["raydium clmm-rfqm", "🦊"] where Bebop serializes the tx with fewer
+        // signature slots than the message header requires.
+        // When rejected, other swappers like Jupiter will handle these pairs instead.
+        const hasAmmRoute = response.data.makers.some(maker => maker.toLowerCase().includes('clmm') || maker.toLowerCase().includes('amm'));
+        if (hasAmmRoute) {
+            return Err(makeSwapErrorRight({
+                message: `Bebop Solana quote contains AMM routing (${response.data.makers.join(', ')}), which produces malformed txs`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        return Ok(response.data);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Unexpected error fetching Bebop Solana quote',
+            cause: error,
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};
+export const fetchBebopSolanaPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }) => {
+    const address = receiveAddress || BEBOP_SOLANA_DUMMY_ADDRESS;
+    return fetchBebopSolanaQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress: address,
+        receiverAddress: address,
+        slippageTolerancePercentageDecimal: '0.01',
+        affiliateBps,
+        apiKey,
+    });
+};

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

@@ -1,11 +1,23 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
+export declare const isSolanaChainId: (chainId: ChainId) => boolean;
 export declare const assetIdToBebopToken: (assetId: AssetId) => string;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet;
+export declare const assetIdToBebopSolanaToken: (assetId: AssetId) => string;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
 }) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
+/**
+ * Bebop's /order endpoint has a bug where it hardcodes the taker signature placement
+ * at the last signer index. When the taker's pubkey bytes sort before the maker's,
+ * the taker ends up at an earlier index, and Bebop places the sig in the wrong slot.
+ * This causes ghost txs (order returns "Success" but tx silently fails on-chain).
+ *
+ * Returns true if the taker is at the expected index (safe to execute), false otherwise.
+ * Returns false on decode failure.
+ */
+export declare const isBebopSolanaTxSafe: (solanaTxBase64: string, takerAddress: string) => boolean;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;

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

@@ -1,16 +1,27 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
+import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
 import { bn, convertPrecision, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
+import { PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { getAddress } from 'viem';
 import { TradeQuoteError } from '../../../../types.js';
 import { makeSwapErrorRight } from '../../../../utils.js';
 import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../../types.js';
+export const isSolanaChainId = (chainId) => {
+    return chainId === solanaChainId;
+};
 export const assetIdToBebopToken = (assetId) => {
     if (!isToken(assetId))
         return BEBOP_NATIVE_MARKER;
     const { assetReference } = fromAssetId(assetId);
     return getAddress(assetReference);
 };
+export const assetIdToBebopSolanaToken = (assetId) => {
+    const { assetReference, chainId } = fromAssetId(assetId);
+    if (chainId === solanaChainId && !isToken(assetId)) {
+        return 'So11111111111111111111111111111111111111112';
+    }
+    return assetReference;
+};
 export const isSupportedChainId = (chainId) => {
     return bebopSupportedChainIds.includes(chainId);
 };
@@ -40,6 +51,38 @@ export const assertValidTrade = ({ buyAsset, sellAsset, }) => {
     }
     return Ok(true);
 };
+/**
+ * Bebop's /order endpoint has a bug where it hardcodes the taker signature placement
+ * at the last signer index. When the taker's pubkey bytes sort before the maker's,
+ * the taker ends up at an earlier index, and Bebop places the sig in the wrong slot.
+ * This causes ghost txs (order returns "Success" but tx silently fails on-chain).
+ *
+ * Returns true if the taker is at the expected index (safe to execute), false otherwise.
+ * Returns false on decode failure.
+ */
+export const isBebopSolanaTxSafe = (solanaTxBase64, takerAddress) => {
+    try {
+        const tx = VersionedTransaction.deserialize(Buffer.from(solanaTxBase64, 'base64'));
+        const numSigners = tx.message.header.numRequiredSignatures;
+        if (numSigners < 1) {
+            console.warn('[Bebop Solana] Transaction has no required signers. Rejecting as malformed.');
+            return false;
+        }
+        const signerKeys = tx.message.staticAccountKeys.slice(0, numSigners);
+        const takerPubkey = new PublicKey(takerAddress);
+        const takerIndex = signerKeys.findIndex(key => key.equals(takerPubkey));
+        const expectedIndex = numSigners - 1; // Bebop hardcodes to last signer slot
+        if (takerIndex !== expectedIndex) {
+            console.warn(`[Bebop Solana] Taker signer index ${takerIndex}, expected ${expectedIndex}. Rejecting to avoid ghost tx.`);
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        console.error(`[Bebop Solana] Failed to decode tx for signer check: ${e.message}`);
+        return false;
+    }
+};
 export const calculateRate = ({ buyAmount, sellAmount, buyAsset, sellAsset, }) => {
     return convertPrecision({
         value: buyAmount,

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

@@ -6,6 +6,7 @@ import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTran
 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) => {
@@ -122,7 +123,12 @@ export const getTradeQuote = async (input, _deps) => {
         if (sellAsset.chainId !== solanaChainId)
             return Ok(undefined);
         const txData = buildTx.data.startsWith('0x') ? buildTx.data.slice(2) : buildTx.data;
-        const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(Buffer.from(txData, 'hex')));
+        const 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());
@@ -141,6 +147,7 @@ export const getTradeQuote = async (input, _deps) => {
             return Ok({
                 instructions,
                 addressLookupTableAddresses: addressLookupTableAccountKeys,
+                isOversized,
             });
         }
         catch (error) {
@@ -184,6 +191,15 @@ export const getTradeQuote = async (input, _deps) => {
         ...(solanaTransactionMetadata && {
             solanaTransactionMetadata,
         }),
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            isEstimate: true,
+        }),
     };
     const tradeQuote = {
         id: route.hash,

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

@@ -5,6 +5,7 @@ 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) => {
@@ -107,6 +108,15 @@ export const getTradeRate = async (input, _deps) => {
         accountNumber,
         allowanceContract: route.contract ?? '0x0',
         estimatedExecutionTimeMs: route.timeEstimated * 1000,
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            isEstimate: true,
+        }),
     };
     const tradeRate = {
         id: route.hash,

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

@@ -5,6 +5,7 @@ import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
 import { getCetusTradeData } from './getCetusTradeData.js';
 export const getTradeQuote = async (input, deps) => {
@@ -78,6 +79,15 @@ export const getTradeQuote = async (input, deps) => {
                     sellAsset,
                     allowanceContract: '0x0',
                     estimatedExecutionTimeMs: undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -5,6 +5,7 @@ import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
 import { getCetusTradeData } from './getCetusTradeData.js';
 export const getTradeRate = async (input, deps) => {
@@ -76,6 +77,15 @@ export const getTradeRate = async (input, deps) => {
                     sellAsset,
                     allowanceContract: '0x0',
                     estimatedExecutionTimeMs: undefined,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmount,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

package/dist/esm/swappers/CetusSwapper/utils/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
 import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import { SuiClient } from '@mysten/sui/client';
 import type { Asset } from '@shapeshiftoss/types';
 export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
 export declare const getSuiClient: (rpcUrl: string) => SuiClient;

package/dist/esm/swappers/CetusSwapper/utils/helpers.js

@@ -1,5 +1,5 @@
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import { SuiClient } from '@mysten/sui/client';
 import { fromAssetId } from '@shapeshiftoss/caip';
 let suiClientInstance;
 let aggregatorClientInstance;

package/dist/esm/swappers/ChainflipSwapper/constants.js

@@ -1,4 +1,4 @@
-import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, } from '@shapeshiftoss/caip';
+import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, usdtOnArbitrumOneAssetId, usdtOnSolanaAssetId, wbtcAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { SwapperName } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
@@ -11,10 +11,14 @@ export const ChainflipSupportedChainIds = [
     KnownChainIds.SolanaMainnet,
 ];
 export const ChainflipSupportedAssetIdsByChainId = {
-    [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId],
-    [KnownChainIds.ArbitrumMainnet]: [arbitrumAssetId, usdcOnArbitrumOneAssetId],
+    [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId, wbtcAssetId],
+    [KnownChainIds.ArbitrumMainnet]: [
+        arbitrumAssetId,
+        usdcOnArbitrumOneAssetId,
+        usdtOnArbitrumOneAssetId,
+    ],
     [KnownChainIds.BitcoinMainnet]: [btcAssetId],
-    [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId],
+    [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId, usdtOnSolanaAssetId],
 };
 export const chainIdToChainflipNetwork = {
     [KnownChainIds.EthereumMainnet]: ChainflipNetwork.Ethereum,

package/dist/esm/swappers/ChainflipSwapper/utils/getQuoteOrRate.js

@@ -5,6 +5,7 @@ import { v4 as uuid } from 'uuid';
 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 { CHAINFLIP_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_QUOTE, CHAINFLIP_DCA_SWAP_SOURCE, CHAINFLIP_REGULAR_QUOTE, CHAINFLIP_SWAP_SOURCE, usdcAsset, } from '../constants.js';
 import { chainflipService } from './chainflipService.js';
 import { getEvmTxFees } from './getEvmTxFees.js';
@@ -239,6 +240,14 @@ export const getQuoteOrRate = async (input, deps) => {
                                 : undefined,
                             chainflipMaxBoostFee: getMaxBoostFee(),
                         },
+                        affiliateFee: buildAffiliateFee({
+                            strategy: 'buy_asset',
+                            affiliateBps: commissionBps,
+                            sellAsset,
+                            buyAsset,
+                            sellAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.ingressAmountNative,
+                            buyAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.egressAmountNative,
+                        }),
                     },
                 ],
             };
@@ -290,6 +299,14 @@ export const getQuoteOrRate = async (input, deps) => {
                             : undefined,
                         chainflipMaxBoostFee: 0,
                     },
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps: commissionBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: singleQuoteResponse.ingressAmountNative ?? '0',
+                        buyAmountCryptoBaseUnit: singleQuoteResponse.egressAmountNative ?? '0',
+                    }),
                 },
             ],
         };

package/dist/esm/swappers/CowSwapper/getCowSwapTradeQuote/getCowSwapTradeQuote.js

@@ -8,6 +8,7 @@ import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, }
 import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../cowswap-utils/constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { cowService } from '../utils/cowService.js';
 import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
@@ -113,6 +114,15 @@ export async function getCowSwapTradeQuote(input, config) {
                 buyAmountBeforeFeesCryptoBaseUnit,
                 buyAmountAfterFeesCryptoBaseUnit,
                 source: SwapperName.CowSwap,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                }),
                 buyAsset,
                 sellAsset,
                 accountNumber,

package/dist/esm/swappers/CowSwapper/getCowSwapTradeRate/getCowSwapTradeRate.js

@@ -8,6 +8,7 @@ import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, }
 import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../cowswap-utils/constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { cowService } from '../utils/cowService.js';
 import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers/helpers.js';
@@ -113,6 +114,14 @@ export async function getCowSwapTradeRate(input, config) {
                 buyAmountBeforeFeesCryptoBaseUnit,
                 buyAmountAfterFeesCryptoBaseUnit,
                 source: SwapperName.CowSwap,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                }),
                 buyAsset,
                 sellAsset,
                 accountNumber,

package/dist/esm/swappers/DebridgeSwapper/DebridgeSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const debridgeSwapper: Swapper;

package/dist/esm/swappers/DebridgeSwapper/DebridgeSwapper.js

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

package/dist/esm/swappers/DebridgeSwapper/constant.d.ts

@@ -0,0 +1,5 @@
+export declare const chainIdToDebridgeChainId: Record<string, number>;
+export declare const debridgeChainIdToChainId: import("lodash").Dictionary<string>;
+export declare const DEBRIDGE_SUPPORTED_CHAIN_IDS: string[];
+export declare const DEFAULT_DEBRIDGE_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_DEBRIDGE_USER_ADDRESS = "0x000000000000000000000000000000000000dead";

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

@@ -0,0 +1,30 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, cronosChainId, ethChainId, flowEvmChainId, gnosisChainId, hyperEvmChainId, lineaChainId, mantleChainId, megaethChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, seiChainId, sonicChainId, storyChainId, } from '@shapeshiftoss/caip';
+import invert from 'lodash/invert';
+import { zeroAddress } from 'viem';
+export const chainIdToDebridgeChainId = {
+    [ethChainId]: 1,
+    [optimismChainId]: 10,
+    [bscChainId]: 56,
+    [gnosisChainId]: 100000002,
+    [polygonChainId]: 137,
+    [monadChainId]: 100000030,
+    [hyperEvmChainId]: 100000022,
+    [seiChainId]: 100000027,
+    [baseChainId]: 8453,
+    [plasmaChainId]: 100000028,
+    [arbitrumChainId]: 42161,
+    [avalancheChainId]: 43114,
+    [mantleChainId]: 100000023,
+    [cronosChainId]: 100000019,
+    [berachainChainId]: 100000020,
+    [lineaChainId]: 59144,
+    [bobChainId]: 100000021,
+    [sonicChainId]: 100000014,
+    [storyChainId]: 100000013,
+    [flowEvmChainId]: 100000009,
+    [megaethChainId]: 100000031,
+};
+export const debridgeChainIdToChainId = invert(chainIdToDebridgeChainId);
+export const DEBRIDGE_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToDebridgeChainId);
+export const DEFAULT_DEBRIDGE_TOKEN_ADDRESS = zeroAddress;
+export const DEFAULT_DEBRIDGE_USER_ADDRESS = '0x000000000000000000000000000000000000dead';

package/dist/esm/swappers/DebridgeSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const debridgeApi: SwapperApi;