@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,138 @@
+import { getQuotes } from '@avnu/avnu-sdk';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getTreasuryAddressFromChainId } from 'packages/swapper/src/swappers/utils/helpers/helpers';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
+import { getTokenAddress } from '../utils/helpers.js';
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${sellAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${buyAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (accountNumber === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `accountNumber is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (sendAddress === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `sendAddress is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (receiveAddress === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `receiveAddress is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    try {
+        const sellTokenAddress = getTokenAddress(sellAsset);
+        const buyTokenAddress = getTokenAddress(buyAsset);
+        const quotes = await getQuotes({
+            sellTokenAddress,
+            buyTokenAddress,
+            sellAmount: BigInt(sellAmount),
+            takerAddress: sendAddress,
+            size: 1,
+            integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
+            integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
+        });
+        if (!quotes || quotes.length === 0) {
+            return Err(makeSwapErrorRight({
+                message: 'No quotes available for this trade pair',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const bestQuote = quotes[0];
+        if (!bestQuote) {
+            return Err(makeSwapErrorRight({
+                message: 'No valid quote returned from AVNU',
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
+        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+        const feeData = await sellAdapter.getFeeData({
+            to: receiveAddress,
+            value: sellAmount,
+            chainSpecific: {
+                from: sendAddress,
+                tokenContractAddress: sellTokenAddress,
+            },
+            sendMax: false,
+        });
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const protocolFees = affiliateBps
+            ? {
+                [buyAsset.assetId]: {
+                    amountCryptoBaseUnit: bn(buyAmountAfterFeesCryptoBaseUnit)
+                        .times(affiliateBps)
+                        .div(10000)
+                        .toFixed(0),
+                    requiresBalance: false,
+                    asset: buyAsset,
+                },
+            }
+            : {};
+        const tradeQuote = {
+            id: uuid(),
+            receiveAddress,
+            affiliateBps,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
+            quoteOrRate: 'quote',
+            swapperName: SwapperName.Avnu,
+            steps: [
+                {
+                    accountNumber,
+                    allowanceContract: '0x0',
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    buyAsset,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
+                    },
+                    rate,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    sellAsset,
+                    source: SwapperName.Avnu,
+                    estimatedExecutionTimeMs: undefined,
+                    avnuSpecific: {
+                        quoteId: bestQuote.quoteId,
+                        routes: bestQuote.routes,
+                    },
+                },
+            ],
+        };
+        return Ok([tradeQuote]);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting AVNU quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -0,0 +1,116 @@
+import { getQuotes } from '@avnu/avnu-sdk';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getTreasuryAddressFromChainId } from 'packages/swapper/src/swappers/utils/helpers/helpers';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { AVNU_SUPPORTED_CHAIN_IDS } from '../utils/constants.js';
+import { getTokenAddress } from '../utils/helpers.js';
+export const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, receiveAddress, } = input;
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${sellAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!AVNU_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `Chain ${buyAsset.chainId} is not supported by AVNU`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    try {
+        const sellTokenAddress = getTokenAddress(sellAsset);
+        const buyTokenAddress = getTokenAddress(buyAsset);
+        const quotes = await getQuotes({
+            sellTokenAddress,
+            buyTokenAddress,
+            sellAmount: BigInt(sellAmount),
+            size: 1,
+            integratorFees: affiliateBps ? BigInt(affiliateBps) : undefined,
+            integratorFeeRecipient: getTreasuryAddressFromChainId(sellAsset.chainId),
+        });
+        if (!quotes || quotes.length === 0) {
+            return Err(makeSwapErrorRight({
+                message: 'No quotes available for this trade pair',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const bestQuote = quotes[0];
+        if (!bestQuote) {
+            return Err(makeSwapErrorRight({
+                message: 'No valid quote returned from AVNU',
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = bestQuote.buyAmount.toString();
+        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+        // For rate quotes, use receiveAddress as a dummy from/to for fee estimation
+        const feeData = await sellAdapter.getFeeData({
+            to: receiveAddress ?? '',
+            value: sellAmount,
+            chainSpecific: {
+                from: receiveAddress ?? '',
+                tokenContractAddress: sellTokenAddress,
+            },
+            sendMax: false,
+        });
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const protocolFees = affiliateBps
+            ? {
+                [buyAsset.assetId]: {
+                    amountCryptoBaseUnit: bn(buyAmountAfterFeesCryptoBaseUnit)
+                        .times(affiliateBps)
+                        .div(10000)
+                        .toFixed(0),
+                    requiresBalance: false,
+                    asset: buyAsset,
+                },
+            }
+            : {};
+        const tradeRate = {
+            id: uuid(),
+            receiveAddress,
+            affiliateBps,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Avnu),
+            quoteOrRate: 'rate',
+            swapperName: SwapperName.Avnu,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    allowanceContract: '0x0',
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    buyAsset,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
+                    },
+                    rate,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    sellAsset,
+                    source: SwapperName.Avnu,
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        return Ok([tradeRate]);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting AVNU rate',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { KnownChainIds } from '@shapeshiftoss/types';
+export type AvnuSupportedChainId = typeof KnownChainIds.StarknetMainnet;

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/swappers/AvnuSwapper/utils/constants.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const AVNU_SUPPORTED_CHAIN_IDS: readonly ChainId[];
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;
+export declare const DEFAULT_SLIPPAGE_PERCENTAGE = "0.005";
+export declare const AVNU_API_BASE_URL = "https://starknet.api.avnu.fi";

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

@@ -0,0 +1,7 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const AVNU_SUPPORTED_CHAIN_IDS = [KnownChainIds.StarknetMainnet];
+export const isSupportedChainId = (chainId) => {
+    return AVNU_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+export const DEFAULT_SLIPPAGE_PERCENTAGE = '0.005';
+export const AVNU_API_BASE_URL = 'https://starknet.api.avnu.fi';

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

@@ -0,0 +1,7 @@
+import type { Asset } from '@shapeshiftoss/types';
+/**
+ * Get the token address for AVNU swaps
+ * For native STRK token (slip44 namespace), returns the STRK contract address
+ * For other tokens, returns the token contract address from assetReference
+ */
+export declare const getTokenAddress: (asset: Asset) => string;

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

@@ -0,0 +1,17 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+// STRK native token contract address on Starknet
+const AVNU_STRK_NATIVE_ADDRESS = '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';
+/**
+ * Get the token address for AVNU swaps
+ * For native STRK token (slip44 namespace), returns the STRK contract address
+ * For other tokens, returns the token contract address from assetReference
+ */
+export const getTokenAddress = (asset) => {
+    const { assetReference, assetNamespace } = fromAssetId(asset.assetId);
+    // For native STRK token, the assetReference is 'slip44:9004' but AVNU expects the STRK contract address
+    if (assetNamespace === 'slip44') {
+        return AVNU_STRK_NATIVE_ADDRESS;
+    }
+    // For other tokens, the assetReference should be the token contract address
+    return assetReference;
+};

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