@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/fetchArbitrumBridgeSwap.d.ts

@@ -0,0 +1,35 @@
+import type { ChildToParentTransactionRequest, ParentToChildTransactionRequest } from '@arbitrum/sdk/dist/lib/dataEntities/transactionRequest';
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Asset } from '@shapeshiftoss/types';
+type FetchArbitrumBridgePriceInput = {
+    supportsEIP1559: false;
+    chainId: ChainId;
+    buyAsset: Asset;
+    receiveAddress: string | undefined;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    sellAsset: Asset;
+    sendAddress: undefined;
+    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
+};
+export type FetchArbitrumBridgeQuoteInput = {
+    supportsEIP1559: boolean;
+    chainId: ChainId;
+    buyAsset: Asset;
+    receiveAddress: string;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    sellAsset: Asset;
+    sendAddress: string;
+    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
+};
+export declare const fetchArbitrumBridgePrice: (args: FetchArbitrumBridgePriceInput) => Promise<{
+    request: Omit<ParentToChildTransactionRequest | ChildToParentTransactionRequest, 'retryableData'> | undefined;
+    allowanceContract: string;
+    networkFeeCryptoBaseUnit: string;
+}>;
+export declare const fetchArbitrumBridgeQuote: (args: FetchArbitrumBridgeQuoteInput) => Promise<{
+    request: Omit<ParentToChildTransactionRequest | ChildToParentTransactionRequest, 'retryableData'> | undefined;
+    allowanceContract: string;
+    networkFeeCryptoBaseUnit: string;
+}>;
+export {};

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/fetchArbitrumBridgeSwap.js

@@ -0,0 +1,143 @@
+import { Erc20Bridger, EthBridger, getArbitrumNetwork } from '@arbitrum/sdk';
+import { ethAssetId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
+import { getEthersV5Provider } from '@shapeshiftoss/contracts';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import { BigNumber } from 'ethers5';
+import { arbitrum } from 'viem/chains';
+import { BRIDGE_TYPE } from '../types.js';
+import { getNetworkFeeOrFallbackCryptoBaseUnit } from './helpers.js';
+const fetchArbitrumBridgeSwap = async ({ chainId, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, sendAddress, receiveAddress, supportsEIP1559, assertGetEvmChainAdapter, quoteOrRate, }) => {
+    if (quoteOrRate === 'quote' && !receiveAddress)
+        throw new Error('receiveAddress is required for Arbitrum Bridge quotes');
+    if (quoteOrRate === 'quote' && !sendAddress)
+        throw new Error('sendAddress is required for Arbitrum Bridge quotes');
+    const adapter = assertGetEvmChainAdapter(chainId);
+    const l2Network = await getArbitrumNetwork(arbitrum.id);
+    const isDeposit = sellAsset.chainId === ethChainId;
+    const isEthBridge = isDeposit ? sellAsset.assetId === ethAssetId : buyAsset.assetId === ethAssetId;
+    const bridgeType = (() => {
+        if (isDeposit) {
+            return isEthBridge ? BRIDGE_TYPE.ETH_DEPOSIT : BRIDGE_TYPE.ERC20_DEPOSIT;
+        }
+        return isEthBridge ? BRIDGE_TYPE.ETH_WITHDRAWAL : BRIDGE_TYPE.ERC20_WITHDRAWAL;
+    })();
+    const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
+    const childProvider = getEthersV5Provider(KnownChainIds.ArbitrumMainnet);
+    switch (bridgeType) {
+        case BRIDGE_TYPE.ETH_DEPOSIT: {
+            const bridger = new EthBridger(l2Network);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getDepositToRequest({
+                    parentProvider,
+                    childProvider,
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ETH deposit request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        case BRIDGE_TYPE.ETH_WITHDRAWAL: {
+            const bridger = new EthBridger(l2Network);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getWithdrawalRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ETH withdraw request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        case BRIDGE_TYPE.ERC20_DEPOSIT: {
+            const bridger = new Erc20Bridger(l2Network);
+            const erc20ParentAddress = fromAssetId(sellAsset.assetId).assetReference;
+            const allowanceContract = await bridger.getParentGatewayAddress(erc20ParentAddress, parentProvider);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getDepositRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    parentProvider,
+                    childProvider,
+                    erc20ParentAddress,
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    destinationAddress: receiveAddress,
+                    retryableGasOverrides: {
+                        // https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/TokenDepositUtils.ts#L159
+                        // the gas limit may vary by about 20k due to SSTORE (zero vs nonzero)
+                        // the 30% gas limit increase should cover the difference
+                        gasLimit: { percentIncrease: BigNumber.from(30) },
+                    },
+                })
+                    .catch(e => {
+                    console.error('Error getting ERC20 deposit request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract };
+        }
+        case BRIDGE_TYPE.ERC20_WITHDRAWAL: {
+            const bridger = new Erc20Bridger(l2Network);
+            const erc20ParentAddress = fromAssetId(buyAsset.assetId).assetReference;
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getWithdrawalRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    erc20ParentAddress,
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ERC20 withdraw request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        default:
+            return assertUnreachable(bridgeType);
+    }
+};
+export const fetchArbitrumBridgePrice = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'rate' });
+export const fetchArbitrumBridgeQuote = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'quote' });

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

@@ -0,0 +1,16 @@
+import type { ChildToParentTransactionRequest, ParentToChildTransactionRequest } from '@arbitrum/sdk';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads/build';
+import type { SwapErrorRight } from '../../../types.js';
+import type { BRIDGE_TYPE } from '../types.js';
+export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => Promise<Result<boolean, SwapErrorRight>>;
+export declare const getNetworkFeeOrFallbackCryptoBaseUnit: ({ maybeRequest, bridgeType, supportsEIP1559, adapter, }: {
+    maybeRequest: ParentToChildTransactionRequest | ChildToParentTransactionRequest | undefined;
+    bridgeType: BRIDGE_TYPE;
+    supportsEIP1559: boolean;
+    adapter: EvmChainAdapter;
+}) => Promise<string>;

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

@@ -0,0 +1,95 @@
+import { Erc20Bridger, getArbitrumNetwork } from '@arbitrum/sdk';
+import { arbitrumAssetId, ethAssetId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { getEthersV5Provider } from '@shapeshiftoss/contracts';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { Err, Ok } from '@sniptt/monads/build';
+import { getAddress, isAddressEqual } from 'viem';
+import { arbitrum } from 'viem/chains';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT } from './constants.js';
+import { arbitrumBridgeSupportedChainIds } from './types.js';
+export const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
+    if (!arbitrumBridgeSupportedChainIds.includes(sellAsset.chainId) ||
+        !arbitrumBridgeSupportedChainIds.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `[ArbitrumBridge: assertValidTrade] - unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    if (buyAsset.chainId === sellAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: `[ArbitrumBridge: assertValidTrade] - both assets must be on different chainIds`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    const isDeposit = sellAsset.chainId === ethChainId;
+    const isEthBridge = isDeposit
+        ? sellAsset.assetId === ethAssetId
+        : sellAsset.assetId === arbitrumAssetId;
+    const isTokenBridge = !isEthBridge;
+    if (isEthBridge) {
+        const isInvalidPair = isDeposit
+            ? buyAsset.assetId !== arbitrumAssetId
+            : buyAsset.assetId !== ethAssetId;
+        if (isInvalidPair) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid ETH bridge pair`,
+                code: TradeQuoteError.UnsupportedTradePair,
+                details: { buyAsset, sellAsset },
+            }));
+        }
+    }
+    if (isTokenBridge) {
+        const childNetwork = await getArbitrumNetwork(arbitrum.id);
+        const bridger = new Erc20Bridger(childNetwork);
+        const erc20ParentAddress = fromAssetId((isDeposit ? sellAsset : buyAsset).assetId).assetReference;
+        const erc20ChildAddress = fromAssetId((isDeposit ? buyAsset : sellAsset).assetId).assetReference;
+        const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
+        const childProvider = getEthersV5Provider(KnownChainIds.ArbitrumMainnet);
+        // Since our related assets list isn't exhaustive and won't cut it to determine the Parent <-> Child mapping, we double check that the bridge is valid
+        // by checking against Arbitrum bridge's own mappings, which uses different sources (Coingecko, Gemini, Uni and its own lists at the time of writing)
+        const arbitrumBridgeErc20ChildAddress = await bridger.getChildErc20Address(erc20ParentAddress, parentProvider);
+        const arbitrumBridgeErc20ParentAddress = await bridger.getParentErc20Address(erc20ChildAddress, childProvider);
+        if (!isAddressEqual(getAddress(arbitrumBridgeErc20ParentAddress), getAddress(erc20ParentAddress))) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid Parent ERC20 address: ${erc20ParentAddress}`,
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        if (!isAddressEqual(getAddress(arbitrumBridgeErc20ChildAddress), getAddress(erc20ChildAddress))) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid Child ERC20 address: ${erc20ChildAddress}`,
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+    }
+    return Ok(true);
+};
+export const getNetworkFeeOrFallbackCryptoBaseUnit = async ({ maybeRequest, bridgeType, supportsEIP1559, adapter, }) => {
+    // Fallback fees
+    if (!maybeRequest) {
+        const { average } = await adapter.getGasFeeData();
+        const { gasPrice, maxFeePerGas } = average;
+        const fallbackGasLimit = BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT[bridgeType];
+        // eip1559 fees
+        if (supportsEIP1559 && maxFeePerGas) {
+            return fallbackGasLimit.times(maxFeePerGas).toFixed();
+        }
+        // legacy fees
+        return fallbackGasLimit.times(gasPrice).toFixed();
+    }
+    // Actual fees
+    const feeData = await evm.getFees({
+        adapter,
+        data: maybeRequest.txRequest.data.toString(),
+        to: maybeRequest.txRequest.to,
+        value: maybeRequest.txRequest.value.toString(),
+        from: maybeRequest.txRequest.from,
+        supportsEIP1559,
+    });
+    return feeData.networkFeeCryptoBaseUnit;
+};

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/types.d.ts

@@ -0,0 +1,3 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const arbitrumBridgeSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet];
+export type ArbitrumBridgeSupportedChainId = (typeof arbitrumBridgeSupportedChainIds)[number];

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/types.js

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const arbitrumBridgeSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+];

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

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

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

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

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

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

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

@@ -0,0 +1,55 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import BigNumber from 'bignumber.js';
+import { fromHex } from 'viem';
+import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getBebopTradeQuote } from './getBebopTradeQuote/getBebopTradeQuote.js';
+import { getBebopTradeRate } from './getBebopTradeRate/getBebopTradeRate.js';
+export const bebopApi = {
+    getTradeQuote: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
+        const tradeQuoteResult = await getBebopTradeQuote(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
+        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+    },
+    getTradeRate: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
+        const tradeRateResult = await getBebopTradeRate(input, assertGetEvmChainAdapter, assetsById, config.VITE_BEBOP_API_KEY);
+        return tradeRateResult.map(tradeRate => [tradeRate]);
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, bebopTransactionMetadata } = step;
+        if (!bebopTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { value: hexValue, to, data, gas } = bebopTransactionMetadata;
+        const value = fromHex(hexValue, 'bigint').toString();
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        if (!gas) {
+            throw new Error('Bebop API did not provide gas estimate - cannot execute trade safely');
+        }
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            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(),
+        });
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { sellAsset, bebopTransactionMetadata } = step;
+        if (!bebopTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { value: hexValue, to, data } = bebopTransactionMetadata;
+        const value = fromHex(hexValue, 'bigint').toString();
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    checkTradeStatus: checkEvmSwapStatus,
+};

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

@@ -0,0 +1,6 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeQuoteInputBase, SwapErrorRight, TradeQuote } from '../../../types.js';
+export declare function getBebopTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, _assetsById: AssetsByIdPartial, apiKey: string): Promise<Result<TradeQuote, SwapErrorRight>>;

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

@@ -0,0 +1,113 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { isAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { BEBOP_DUMMY_ADDRESS } from '../types.js';
+import { fetchBebopQuote } from '../utils/fetchFromBebop.js';
+import { assertValidTrade, calculateRate } from '../utils/helpers/helpers.js';
+export async function getBebopTradeQuote(input, assertGetEvmChainAdapter, _assetsById, apiKey) {
+    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const takerAddress = (sendAddress || receiveAddress);
+    if (takerAddress === BEBOP_DUMMY_ADDRESS) {
+        return Err(makeSwapErrorRight({
+            message: 'Cannot execute quote with dummy address - wallet required',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
+    const maybeBebopQuoteResponse = await fetchBebopQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress,
+        receiverAddress: receiveAddress,
+        slippageTolerancePercentageDecimal,
+        affiliateBps,
+        apiKey,
+    });
+    if (maybeBebopQuoteResponse.isErr())
+        return Err(maybeBebopQuoteResponse.unwrapErr());
+    const bebopQuoteResponse = maybeBebopQuoteResponse.unwrap();
+    const bestRoute = bebopQuoteResponse.routes.find(r => r.type === bebopQuoteResponse.bestPrice);
+    if (!bestRoute || !bestRoute.quote) {
+        return Err(makeSwapErrorRight({
+            message: 'No best route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const quote = bestRoute.quote;
+    const sellTokenAddress = Object.keys(quote.sellTokens)[0];
+    const buyTokenAddress = Object.keys(quote.buyTokens)[0];
+    if (!isAddress(sellTokenAddress) || !isAddress(buyTokenAddress)) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const sellAmount = quote.sellTokens[sellTokenAddress].amount;
+    const buyAmount = quote.buyTokens[buyTokenAddress].amount;
+    const transactionMetadata = {
+        to: quote.tx.to,
+        data: quote.tx.data,
+        value: quote.tx.value,
+        gas: quote.tx.gas?.toString(),
+    };
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = quote.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    try {
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const { fast } = await adapter.getGasFeeData();
+        const gasLimitFromQuote = bnOrZero(quote.tx.gas).toString();
+        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+            ...fast,
+            supportsEIP1559: Boolean(supportsEIP1559),
+            gasLimit: gasLimitFromQuote,
+        });
+        return Ok({
+            id: uuid(),
+            quoteOrRate: 'quote',
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+            rate,
+            swapperName: SwapperName.Bebop,
+            steps: [
+                {
+                    estimatedExecutionTimeMs: 0,
+                    allowanceContract: isNativeEvmAsset(sellAsset.assetId) ? undefined : quote.approvalTarget,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    rate,
+                    feeData: {
+                        protocolFees: {},
+                        networkFeeCryptoBaseUnit,
+                    },
+                    buyAmountBeforeFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    source: SwapperName.Bebop,
+                    bebopTransactionMetadata: transactionMetadata,
+                },
+            ],
+        });
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: 'Failed to get fee data',
+            cause: err,
+            code: TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeRateInput, SwapErrorRight, TradeRate } from '../../../types.js';
+export declare function getBebopTradeRate(input: GetEvmTradeRateInput, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, _assetsById: AssetsByIdPartial, apiKey: string): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,88 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { isAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { fetchBebopPrice } from '../utils/fetchFromBebop.js';
+import { assertValidTrade, calculateRate } from '../utils/helpers/helpers.js';
+export async function getBebopTradeRate(input, assertGetEvmChainAdapter, _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 fetchBebopPrice({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        receiveAddress,
+        affiliateBps,
+        apiKey,
+    });
+    if (maybeBebopPriceResponse.isErr())
+        return Err(maybeBebopPriceResponse.unwrapErr());
+    const bebopPriceResponse = maybeBebopPriceResponse.unwrap();
+    const bestRoute = bebopPriceResponse.routes.find(r => r.type === bebopPriceResponse.bestPrice);
+    if (!bestRoute || !bestRoute.quote) {
+        return Err(makeSwapErrorRight({
+            message: 'No best route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const quote = bestRoute.quote;
+    const sellTokenAddress = Object.keys(quote.sellTokens)[0];
+    const buyTokenAddress = Object.keys(quote.buyTokens)[0];
+    if (!isAddress(sellTokenAddress) || !isAddress(buyTokenAddress)) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const sellAmount = quote.sellTokens[sellTokenAddress].amount;
+    const buyAmount = quote.buyTokens[buyTokenAddress].amount;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = quote.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getGasFeeData();
+    const gasLimit = bnOrZero(quote.tx.gas).toString();
+    const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+        ...fast,
+        supportsEIP1559: Boolean(input.supportsEIP1559),
+        gasLimit,
+    });
+    return Ok({
+        id: uuid(),
+        quoteOrRate: 'rate',
+        accountNumber: undefined,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        rate,
+        swapperName: SwapperName.Bebop,
+        steps: [
+            {
+                estimatedExecutionTimeMs: 0,
+                allowanceContract: isNativeEvmAsset(sellAsset.assetId) ? undefined : quote.approvalTarget,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                rate,
+                feeData: {
+                    protocolFees: {},
+                    networkFeeCryptoBaseUnit,
+                },
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                source: SwapperName.Bebop,
+            },
+        ],
+    });
+}

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

@@ -0,0 +1,2 @@
+export { bebopSwapper } from './BebopSwapper.js';
+export { bebopApi } from './endpoints.js';

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

@@ -0,0 +1,2 @@
+export { bebopSwapper } from './BebopSwapper.js';
+export { bebopApi } from './endpoints.js';