@shapeshiftoss/swapper 17.6.3 → 17.6.5

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

@@ -0,0 +1,89 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { Address, Hex } from 'viem';
+export declare const bebopSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet];
+export type BebopSupportedChainId = (typeof bebopSupportedChainIds)[number];
+export type BebopQuoteRoute = {
+    type: string;
+    quote: {
+        requestId: string;
+        type: string;
+        status: string;
+        quoteId: string;
+        chainId: number;
+        approvalType: 'Standard' | 'Permit2';
+        nativeToken: string;
+        taker: Address;
+        receiver: Address;
+        expiry: number;
+        slippage: number;
+        gasFee: {
+            native: string;
+            usd: number;
+        };
+        buyTokens: Record<Address, {
+            amount: string;
+            decimals: number;
+            priceUsd: number;
+            symbol: string;
+            minimumAmount: string;
+            price: number;
+            priceBeforeFee: number;
+            amountBeforeFee: string;
+            deltaFromExpected: number;
+        }>;
+        sellTokens: Record<Address, {
+            amount: string;
+            decimals: number;
+            priceUsd: number;
+            symbol: string;
+            price: number;
+            priceBeforeFee: number;
+        }>;
+        settlementAddress: Address;
+        approvalTarget: Address;
+        requiredSignatures: string[];
+        priceImpact: number;
+        warnings: string[];
+        toSign: {
+            partner_id: number;
+            expiry: number;
+            taker_address: Address;
+            maker_address: Address;
+            maker_nonce: string;
+            taker_token: Address;
+            maker_token: Address;
+            taker_amount: string;
+            maker_amount: string;
+            receiver: Address;
+            packed_commands: string;
+        };
+        onchainOrderType?: string;
+        solver?: string;
+        makers?: string[];
+        partialFillOffset?: number;
+        tx: {
+            to: Address;
+            from: Address;
+            data: Hex;
+            value: Hex;
+            gas?: number;
+            gasPrice?: number;
+        };
+        partnerFee?: Record<Address, string>;
+        protocolFee?: Record<Address, string>;
+    };
+};
+export type BebopError = {
+    errorCode: number;
+    message: string;
+    requestId: string;
+};
+export type BebopQuoteResponse = {
+    routes: BebopQuoteRoute[];
+    errors: Record<string, BebopError>;
+    link: string;
+    bestPrice: string;
+};
+export declare const chainIdToBebopChain: Record<BebopSupportedChainId, string>;
+export declare const BEBOP_NATIVE_MARKER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const BEBOP_DUMMY_ADDRESS: `0x${string}`;

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

@@ -0,0 +1,24 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const bebopSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BaseMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+];
+export const chainIdToBebopChain = {
+    [KnownChainIds.EthereumMainnet]: 'ethereum',
+    [KnownChainIds.PolygonMainnet]: 'polygon',
+    [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [KnownChainIds.BaseMainnet]: 'base',
+    [KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [KnownChainIds.OptimismMainnet]: 'optimism',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+};
+export const BEBOP_NATIVE_MARKER = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+// Dummy address used for rate quotes when no wallet is connected.
+// This is Vitalik's address, same as what Bebop's own UI uses for price-only quotes.
+// MUST NEVER be used for executable quote transactions.
+export const BEBOP_DUMMY_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';

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

@@ -0,0 +1,9 @@
+import type { AxiosInstance } from 'axios';
+import type { RetryConfig } from 'retry-axios';
+import type { MonadicSwapperAxiosService } from '../../../types.js';
+type AxiosInstanceHoF = (instance: AxiosInstance, options?: Omit<RetryConfig, 'instance'>) => AxiosInstance;
+export declare const bebopServiceFactory: ({ apiKey, wrapper, }: {
+    apiKey: string;
+    wrapper?: AxiosInstanceHoF | undefined;
+}) => MonadicSwapperAxiosService;
+export {};

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

@@ -0,0 +1,24 @@
+import identity from 'lodash/identity';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAge = 5 * 1000;
+const cachedUrls = ['/quote', '/price'];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+    },
+};
+export const bebopServiceFactory = ({ apiKey, wrapper = identity, }) => {
+    const configWithAuth = {
+        ...axiosConfig,
+        headers: {
+            ...axiosConfig.headers,
+            'x-api-key': apiKey,
+            'source-auth': apiKey,
+        },
+    };
+    const cache = createCache(maxAge, cachedUrls, configWithAuth);
+    const axiosInstance = wrapper(cache);
+    return makeSwapperAxiosServiceMonadic(axiosInstance);
+};

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

@@ -0,0 +1,23 @@
+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';
+export declare const fetchBebopQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    takerAddress: Address;
+    receiverAddress: Address;
+    slippageTolerancePercentageDecimal: string;
+    affiliateBps?: string | undefined;
+    apiKey: string;
+}) => Promise<Result<BebopQuoteResponse, SwapErrorRight>>;
+export declare const fetchBebopPrice: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    receiveAddress: string | undefined;
+    affiliateBps?: string | undefined;
+    apiKey: string;
+}) => Promise<Result<BebopQuoteResponse, SwapErrorRight>>;

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

@@ -0,0 +1,88 @@
+import { bn } from '@shapeshiftoss/utils';
+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 { bebopServiceFactory } from './bebopService.js';
+import { assetIdToBebopToken } from './helpers/helpers.js';
+export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
+    try {
+        const sellToken = assetIdToBebopToken(sellAsset.assetId);
+        const buyToken = assetIdToBebopToken(buyAsset.assetId);
+        const checksummedTakerAddress = getAddress(takerAddress);
+        const checksummedReceiverAddress = getAddress(receiverAddress);
+        const chainName = chainIdToBebopChain[sellAsset.chainId];
+        const sellAmountFormatted = bn(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0);
+        // Bebop API expects slippage as percentage (not basis points like other APIs)
+        // e.g. 0.3% → send as 0.3, not 30
+        // See: https://api.bebop.xyz/pmm/ethereum/docs#/v3/quote_v3_quote_get
+        const slippagePercentage = bn(slippageTolerancePercentageDecimal ?? 0.003)
+            .times(100)
+            .toNumber();
+        const url = `https://api.bebop.xyz/router/${chainName}/v1/quote`;
+        const params = new URLSearchParams({
+            sell_tokens: sellToken,
+            buy_tokens: buyToken,
+            sell_amounts: sellAmountFormatted,
+            taker_address: checksummedTakerAddress,
+            receiver_address: checksummedReceiverAddress,
+            slippage: slippagePercentage.toString(),
+            approval_type: 'Standard',
+            skip_validation: 'true',
+            gasless: 'false',
+            source: 'shapeshift',
+        });
+        if (affiliateBps && affiliateBps !== '0') {
+            params.set('fee', affiliateBps);
+        }
+        const bebopService = bebopServiceFactory({ apiKey });
+        const maybeResponse = await bebopService.get(`${url}?${params}`);
+        if (maybeResponse.isErr()) {
+            return Err(makeSwapErrorRight({
+                message: 'Failed to fetch quote from Bebop',
+                cause: maybeResponse.unwrapErr().cause,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const response = maybeResponse.unwrap();
+        // Log partial route failures for debugging (these are normal and don't indicate quote failure)
+        if (response.data.errors && Object.keys(response.data.errors).length > 0) {
+            console.debug('[Bebop] Some routes failed (this is normal):', response.data.errors);
+        }
+        // Validate response has routes - only fail if there are NO valid routes
+        if (!response.data.routes || response.data.routes.length === 0) {
+            return Err(makeSwapErrorRight({
+                message: 'No routes available',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        if (!response.data.bestPrice) {
+            return Err(makeSwapErrorRight({
+                message: 'No best price route specified',
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        return Ok(response.data);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Unexpected error fetching Bebop quote',
+            cause: error,
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};
+export const fetchBebopPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }) => {
+    const address = receiveAddress || BEBOP_DUMMY_ADDRESS;
+    return fetchBebopQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress: address,
+        receiverAddress: address,
+        slippageTolerancePercentageDecimal: '0.01',
+        affiliateBps,
+        apiKey,
+    });
+};

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

@@ -0,0 +1,14 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+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 assertValidTrade: ({ buyAsset, sellAsset, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight>;
+export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
+    buyAmount: string;
+    sellAmount: string;
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => string;

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

@@ -0,0 +1,51 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { bn, convertPrecision, isToken } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getAddress } from 'viem';
+import { TradeQuoteError } from '../../../../types.js';
+import { makeSwapErrorRight } from '../../../../utils.js';
+import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../../types.js';
+export const assetIdToBebopToken = (assetId) => {
+    if (!isToken(assetId))
+        return BEBOP_NATIVE_MARKER;
+    const { assetReference } = fromAssetId(assetId);
+    return getAddress(assetReference);
+};
+export const isSupportedChainId = (chainId) => {
+    return bebopSupportedChainIds.includes(chainId);
+};
+export const assertValidTrade = ({ buyAsset, sellAsset, }) => {
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!isSupportedChainId(sellAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    if (sellAssetChainId !== buyAssetChainId) {
+        return Err(makeSwapErrorRight({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    return Ok(true);
+};
+export const calculateRate = ({ buyAmount, sellAmount, buyAsset, sellAsset, }) => {
+    return convertPrecision({
+        value: buyAmount,
+        inputExponent: buyAsset.precision,
+        outputExponent: sellAsset.precision,
+    })
+        .dividedBy(bn(sellAmount))
+        .toFixed();
+};

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

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

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

@@ -0,0 +1,8 @@
+import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+export const butterSwap = {
+    executeEvmTransaction,
+    executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

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

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

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

@@ -0,0 +1,69 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import BigNumber from 'bignumber.js';
+import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
+import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkTradeStatus } from './swapperApi/checkTradeStatus.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+export const butterSwapApi = {
+    getTradeQuote,
+    getTradeRate,
+    checkTradeStatus,
+    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 { butterSwapTransactionMetadata, sellAsset } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({
+            adapter,
+            data,
+            to,
+            value: BigInt(value).toString(),
+            from,
+            supportsEIP1559,
+        });
+        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+            gasLimit,
+            gasPrice: feeData.gasPrice ?? '0',
+            maxFeePerGas: feeData.maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+            supportsEIP1559,
+        });
+        return BigNumber.max(feeData.networkFeeCryptoBaseUnit, networkFeeCryptoBaseUnit).toFixed();
+    },
+    getUnsignedEvmTransaction: async (args) => {
+        const { from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter } = args;
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, butterSwapTransactionMetadata } = step;
+        if (!butterSwapTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({
+            adapter,
+            data,
+            to,
+            value: BigInt(value).toString(),
+            from,
+            supportsEIP1559,
+        });
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            to,
+            value: BigInt(value).toString(),
+            ...feeData,
+            gasLimit: BigNumber.max(feeData.gasLimit, gasLimit).toFixed(),
+        });
+    },
+    getUnsignedSolanaTransaction,
+    getSolanaTransactionFees,
+};

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

@@ -0,0 +1 @@
+export * from './endpoints.js';

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

@@ -0,0 +1 @@
+export * from './endpoints.js';

package/dist/esm/swappers/ButterSwap/swapperApi/checkTradeStatus.d.ts

@@ -0,0 +1,2 @@
+import type { CheckTradeStatusInput, TradeStatus } from '../../../types.js';
+export declare const checkTradeStatus: (input: CheckTradeStatusInput) => Promise<TradeStatus>;

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

@@ -0,0 +1,85 @@
+import { solanaChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { checkEvmSwapStatus, checkSolanaSwapStatus, createDefaultStatusResponse, } from '../../../utils.js';
+import { getBridgeInfoBySourceHash } from '../xhr.js';
+// See: https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
+// Example endpoint: https://bs-app-api.chainservice.io/api/queryBridgeInfoBySourceHash?hash=0x...
+// State mapping: 0 = pending, 1 = complete, 6 = refunded/failed
+const BUTTER_SWAP_STATES = (() => ({
+    Pending: 0,
+    Confirmed: 1,
+    Failed: 6,
+}))();
+export const checkTradeStatus = async (input) => {
+    const { txHash, chainId: sellChainId, address, swap, assertGetEvmChainAdapter, assertGetSolanaChainAdapter, fetchIsSmartContractAddressQuery, } = input;
+    try {
+        // Same-chain swaps don't go through the bridge indexer. Short-circuit to on-chain status.
+        const isSameChainSwap = Boolean(swap && swap.sellAsset.chainId === swap.buyAsset?.chainId);
+        if (isSameChainSwap) {
+            if (sellChainId === solanaChainId) {
+                return await checkSolanaSwapStatus({
+                    txHash,
+                    address,
+                    assertGetSolanaChainAdapter,
+                });
+            }
+            if (isEvmChainId(sellChainId)) {
+                return await checkEvmSwapStatus({
+                    txHash,
+                    chainId: sellChainId,
+                    address,
+                    assertGetEvmChainAdapter,
+                    fetchIsSmartContractAddressQuery,
+                });
+            }
+            // Fallback: unknown same-chain type (should never happen for Butter, but just in case). Avoid bridge polling.
+            return createDefaultStatusResponse(txHash);
+        }
+        // Fetch bridge info by source hash
+        const infoResult = await getBridgeInfoBySourceHash(txHash);
+        if (infoResult.isErr()) {
+            const error = infoResult.unwrapErr();
+            return {
+                status: TxStatus.Unknown,
+                buyTxHash: undefined,
+                message: error.message,
+            };
+        }
+        const bridgeInfo = infoResult.unwrap();
+        if (!bridgeInfo) {
+            return { status: TxStatus.Unknown, buyTxHash: undefined, message: undefined };
+        }
+        // Use toHash as the destination chain tx hash if present
+        const destinationTxHash = bridgeInfo.toHash ?? undefined;
+        const relayerTxHash = bridgeInfo.relayerHash ?? undefined;
+        const relayerExplorerTxLink = bridgeInfo.relayerChain?.scanUrl ?? undefined;
+        // State mapping: 0 = pending, 1 = complete, 6 = refunded/failed
+        let status = (() => {
+            // Optimistically return Confirmed if we have a destination tx hash, useful to chains with long block
+            // times (e.g. BTC)
+            if (!!destinationTxHash)
+                return TxStatus.Confirmed;
+            switch (bridgeInfo.state) {
+                case BUTTER_SWAP_STATES.Pending:
+                    return TxStatus.Pending;
+                case BUTTER_SWAP_STATES.Confirmed:
+                    return TxStatus.Confirmed;
+                case BUTTER_SWAP_STATES.Failed:
+                    return TxStatus.Failed;
+                default:
+                    return TxStatus.Unknown;
+            }
+        })();
+        return {
+            status,
+            buyTxHash: destinationTxHash,
+            relayerTxHash,
+            relayerExplorerTxLink,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        return { status: TxStatus.Unknown, buyTxHash: undefined, message: e.message };
+    }
+};

package/dist/esm/swappers/ButterSwap/swapperApi/checkTradeStatus.test.d.ts

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