@shapeshiftoss/swapper 17.7.2 → 17.8.0

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

@@ -1,9 +1,11 @@
-import { bn } from '@shapeshiftoss/utils';
+import { solAssetId } from '@shapeshiftoss/caip';
+import { bn, bnOrZero } 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, BEBOP_SOLANA_DUMMY_ADDRESS, chainIdToBebopChain } from '../types.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { chainIdToBebopChain } from '../types.js';
 import { bebopServiceFactory } from './bebopService.js';
 import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers/helpers.js';
 export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
@@ -14,14 +16,8 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
         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({
+        const slippagePercentage = bn(slippageTolerancePercentageDecimal).times(100).toNumber();
+        const baseParams = {
             sell_tokens: sellToken,
             buy_tokens: buyToken,
             sell_amounts: sellAmountFormatted,
@@ -32,38 +28,46 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
             skip_validation: 'true',
             gasless: 'false',
             source: 'shapeshift',
-        });
+        };
+        const jamParams = new URLSearchParams(baseParams);
+        const pmmParams = new URLSearchParams(baseParams);
         if (affiliateBps && affiliateBps !== '0') {
-            params.set('fee', affiliateBps);
+            // JAM collects the fee on-chain and requires a recipient
+            jamParams.set('fee', affiliateBps);
+            jamParams.set('fee_recipient', getAddress(getTreasuryAddressFromChainId(buyAsset.chainId)));
+            // PMM attributes the fee off-chain via source
+            pmmParams.set('fee', affiliateBps);
         }
-        const bebopService = bebopServiceFactory({ apiKey });
-        const maybeResponse = await bebopService.get(`${url}?${params}`);
-        if (maybeResponse.isErr()) {
+        const service = bebopServiceFactory({ apiKey });
+        const [maybeJam, maybePmm] = await Promise.all([
+            service.get(`https://api.bebop.xyz/jam/${chainName}/v2/quote`, {
+                params: jamParams,
+            }),
+            service.get(`https://api.bebop.xyz/pmm/${chainName}/v3/quote`, {
+                params: pmmParams,
+            }),
+        ]);
+        const maybeResponses = [maybeJam, maybePmm];
+        if (maybeResponses.every(maybeResponse => maybeResponse.isErr())) {
             return Err(makeSwapErrorRight({
                 message: 'Failed to fetch quote from Bebop',
-                cause: maybeResponse.unwrapErr().cause,
+                cause: maybeResponses[0].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) {
+        const quotes = maybeResponses
+            .filter(maybeResponse => maybeResponse.isOk())
+            .map(maybeResponse => maybeResponse.unwrap().data)
+            .filter(quote => Boolean(quote.tx?.data));
+        if (!quotes.length) {
             return Err(makeSwapErrorRight({
-                message: 'No routes available',
+                message: 'No route available',
                 code: TradeQuoteError.NoRouteFound,
             }));
         }
-        if (!response.data.bestPrice) {
-            return Err(makeSwapErrorRight({
-                message: 'No best price route specified',
-                code: TradeQuoteError.InvalidResponse,
-            }));
-        }
-        return Ok(response.data);
+        const getBuyAmount = (quote) => bnOrZero(Object.values(quote.buyTokens)[0]?.amount);
+        const bestQuote = quotes.reduce((best, quote) => getBuyAmount(quote).gt(getBuyAmount(best)) ? quote : best);
+        return Ok(bestQuote);
     }
     catch (error) {
         return Err(makeSwapErrorRight({
@@ -73,28 +77,20 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
         }));
     }
 };
-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,
-    });
-};
 export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
+        // Bebop's Solana routes don't wrap native SOL on the input side, so selling native SOL
+        // always fails on-chain. Reject up front instead of returning an unexecutable quote.
+        if (sellAsset.assetId === solAssetId) {
+            return Err(makeSwapErrorRight({
+                message: 'Bebop Solana cannot sell native SOL',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
         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 slippagePercentage = bn(slippageTolerancePercentageDecimal).times(100).toNumber();
         const params = new URLSearchParams({
             sell_tokens: sellToken,
             buy_tokens: buyToken,
@@ -110,8 +106,7 @@ export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountInc
         if (affiliateBps && affiliateBps !== '0') {
             params.set('fee', affiliateBps);
         }
-        const bebopService = bebopServiceFactory({ apiKey });
-        const maybeResponse = await bebopService.get(`${url}?${params}`);
+        const maybeResponse = await bebopServiceFactory({ apiKey }).get('https://api.bebop.xyz/pmm/solana/v3/quote', { params });
         if (maybeResponse.isErr()) {
             const err = maybeResponse.unwrapErr();
             return Err(makeSwapErrorRight({
@@ -133,19 +128,6 @@ export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountInc
                 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) {
@@ -156,16 +138,3 @@ export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountInc
         }));
     }
 };
-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,10 +1,9 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
-import type { BebopSupportedChainId } from '../../types.js';
 export declare const isSolanaChainId: (chainId: ChainId) => boolean;
 export declare const assetIdToBebopToken: (assetId: AssetId) => string;
 export declare const assetIdToBebopSolanaToken: (assetId: AssetId) => string;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is BebopSupportedChainId;
+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;

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

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

package/dist/esm/swappers/BobGatewaySwapper/BobGatewaySwapper.js

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

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

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

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

@@ -0,0 +1,140 @@
+import { isGatewayError } from '@gobob/bob-sdk';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getBobGatewayTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getBobGatewayTradeRate } from './swapperApi/getTradeRate.js';
+import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus, registerBobGatewayTx, } from './utils/helpers.js';
+const registeredSwapIds = new Set();
+export const bobGatewayApi = {
+    getTradeRate: async (input, deps) => {
+        return (await getBobGatewayTradeRate(input, deps)).map(tradeRate => [tradeRate]);
+    },
+    getTradeQuote: async (input, deps) => {
+        return (await getBobGatewayTradeQuote(input, deps)).map(tradeQuote => [tradeQuote]);
+    },
+    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { bobSpecific, sellAsset } = step;
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        if (!bobSpecific?.utxoTx)
+            throw new Error('[BobGateway] invalid utxo transaction');
+        const { depositAddress, opReturnData } = bobSpecific.utxoTx;
+        return adapter.buildSendApiTransaction({
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            xpub,
+            to: depositAddress,
+            accountNumber: step.accountNumber,
+            skipToAddressValidation: true,
+            chainSpecific: {
+                accountType,
+                opReturnData,
+                satoshiPerByte: step.feeData.chainSpecific.satsPerByte,
+            },
+        });
+    },
+    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { bobSpecific, sellAsset } = step;
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        if (!bobSpecific?.utxoTx)
+            throw new Error('[BobGateway] invalid utxo transaction');
+        const { depositAddress, opReturnData } = bobSpecific.utxoTx;
+        const { fast } = await adapter.getFeeData({
+            to: depositAddress,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub, opReturnData },
+            sendMax: false,
+        });
+        return fast.txFee;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, assertGetEvmChainAdapter, supportsEIP1559, }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, bobSpecific, sellAsset } = step;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        if (!bobSpecific?.evmTx)
+            throw new Error('[BobGateway] invalid evm transaction');
+        const { to, data, value } = bobSpecific.evmTx;
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        // Pad the gas limit of the tx we actually broadcast to reduce the risk of out-of-gas reverts.
+        const gasLimit = bnOrZero(feeData.gasLimit).times(1.2).toFixed(0);
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            from,
+            to,
+            value,
+            data,
+            ...feeData,
+            gasLimit,
+        });
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { bobSpecific, sellAsset } = step;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        if (!bobSpecific?.evmTx)
+            throw new Error('[BobGateway] invalid evm transaction');
+        const { to, data, value } = bobSpecific.evmTx;
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    checkTradeStatus: async ({ swap, config, txHash }) => {
+        if (!swap)
+            throw new Error('[BobGateway] swap is required for status check');
+        const orderId = swap.metadata.bobSpecific?.orderId;
+        if (!orderId)
+            throw new Error('[BobGateway] orderId is required for status check');
+        if (txHash && !registeredSwapIds.has(swap.id)) {
+            try {
+                await registerBobGatewayTx({
+                    config,
+                    orderId,
+                    txHash,
+                    sellAsset: swap.sellAsset,
+                    buyAsset: swap.buyAsset,
+                });
+                registeredSwapIds.add(swap.id);
+            }
+            catch { }
+        }
+        let orderInfo;
+        try {
+            orderInfo = await getBobGatewayClient(config).getOrder(orderId);
+        }
+        catch (err) {
+            if (isGatewayError(err)) {
+                if (err.code === 'ORDER_NOT_FOUND') {
+                    return {
+                        buyTxHash: undefined,
+                        status: TxStatus.Unknown,
+                        message: 'Waiting for deposit...',
+                    };
+                }
+            }
+            throw err;
+        }
+        const status = mapBobGatewayOrderStatusToTxStatus(orderInfo.status);
+        const buyTxHash = 'success' in orderInfo.status ? orderInfo.status.success.receivedTokens[0]?.txHash : undefined;
+        const refundTxHash = 'refunded' in orderInfo.status
+            ? orderInfo.status.refunded.refundedTokens[0]?.txHash
+            : undefined;
+        return {
+            status,
+            buyTxHash,
+            message: refundTxHash ? 'Trade refunded' : undefined,
+        };
+    },
+};

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

@@ -0,0 +1,3 @@
+export { bobGatewayApi } from './endpoints.js';
+export { bobGatewaySwapper } from './BobGatewaySwapper.js';
+export * from './utils/constants.js';

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

@@ -0,0 +1,3 @@
+export { bobGatewayApi } from './endpoints.js';
+export { bobGatewaySwapper } from './BobGatewaySwapper.js';
+export * from './utils/constants.js';

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/getTradeQuote.d.ts

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

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

@@ -0,0 +1,86 @@
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { assertValidTrade, createBobGatewayOrderMetadata, getBobGatewayAllowanceContract, getBobGatewayQuote, getBobGatewayQuoteFeeData, parseBobGatewayQuote, } from '../utils/helpers.js';
+export const getBobGatewayTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    if (!sendAddress) {
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] sendAddress is required for quote',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!receiveAddress) {
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] receiveAddress is required for quote',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    // omit the sender for utxo sells so order creation does not enforce a per-address confirmed
+    // funds check (deposits are matched via op_return, not the sending address)
+    const sender = isEvmChainId(sellAsset.chainId) ? sendAddress : undefined;
+    const maybeQuote = await getBobGatewayQuote({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient: receiveAddress,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const maybeOrderMetadata = await createBobGatewayOrderMetadata(config, quote);
+    if (maybeOrderMetadata.isErr())
+        return Err(maybeOrderMetadata.unwrapErr());
+    const orderMetadata = maybeOrderMetadata.unwrap();
+    const maybeFeeData = await getBobGatewayQuoteFeeData(input, deps, orderMetadata);
+    if (maybeFeeData.isErr())
+        return Err(maybeFeeData.unwrapErr());
+    const feeData = maybeFeeData.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = parseBobGatewayQuote(quote, buyAsset, deps.assetsById);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = getBobGatewayAllowanceContract(quote, sellAsset);
+    const tradeQuote = {
+        id: uuid(),
+        quoteOrRate: 'quote',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: { ...feeData, protocolFees },
+                rate,
+                source: SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+                bobSpecific: orderMetadata,
+            },
+        ],
+    };
+    return Ok(tradeQuote);
+};

package/dist/esm/swappers/BobGatewaySwapper/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 getBobGatewayTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,69 @@
+import { btcChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName } from '../../../types.js';
+import { getInputOutputRate } from '../../../utils.js';
+import { DUMMY_BTC_ADDRESS, DUMMY_EVM_ADDRESS } from '../utils/constants.js';
+import { assertValidTrade, getBobGatewayAllowanceContract, getBobGatewayQuote, getBobGatewayRateNetworkFeeCryptoBaseUnit, parseBobGatewayQuote, } from '../utils/helpers.js';
+export const getBobGatewayTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    const recipient = receiveAddress ?? (buyAsset.chainId === btcChainId ? DUMMY_BTC_ADDRESS : DUMMY_EVM_ADDRESS);
+    const sender = sellAsset.chainId === btcChainId ? undefined : DUMMY_EVM_ADDRESS;
+    const maybeQuote = await getBobGatewayQuote({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = parseBobGatewayQuote(quote, buyAsset, deps.assetsById);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = getBobGatewayAllowanceContract(quote, sellAsset);
+    const networkFeeCryptoBaseUnit = await getBobGatewayRateNetworkFeeCryptoBaseUnit(quote, sellAsset, deps);
+    const tradeRate = {
+        id: uuid(),
+        quoteOrRate: 'rate',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: {
+                    networkFeeCryptoBaseUnit,
+                    protocolFees,
+                },
+                rate,
+                source: SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+            },
+        ],
+    };
+    return Ok(tradeRate);
+};

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

@@ -0,0 +1,20 @@
+type BobGatewayEvmTxMetadata = {
+    to: string;
+    data: string;
+    value: string;
+    chain: string;
+};
+type BobGatewayUtxoTxMetadata = {
+    depositAddress: string;
+    opReturnData?: string;
+};
+export type BobGatewayMetadata = {
+    orderId: string;
+} & ({
+    evmTx: BobGatewayEvmTxMetadata;
+    utxoTx?: never;
+} | {
+    utxoTx: BobGatewayUtxoTxMetadata;
+    evmTx?: never;
+});
+export {};

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

@@ -0,0 +1,13 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const BOB_GATEWAY_BASE_URL = "https://gateway-api-mainnet.gobob.xyz";
+export declare const chainIdToBobGatewayChainName: {
+    readonly [x: string]: "arbitrum" | "avalanche" | "base" | "bera" | "bitcoin" | "bob" | "bsc" | "ethereum" | "sei" | "sonic" | "unichain";
+};
+export declare const bobGatewayChainNameToChainId: Record<BobGatewayChainName, ChainId>;
+export type BobGatewayChainName = (typeof chainIdToBobGatewayChainName)[keyof typeof chainIdToBobGatewayChainName];
+export declare const DUMMY_EVM_ADDRESS: `0x${string}`;
+export declare const DUMMY_BTC_ADDRESS = "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq";
+export declare const BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = "350000";
+export declare const BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = "550000";
+export declare const BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = "200";
+export declare const decimalSlippageToBobBps: (slippageDecimal: string) => string;

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

@@ -0,0 +1,27 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, btcChainId, ethChainId, seiChainId, sonicChainId, unichainChainId, } from '@shapeshiftoss/caip';
+export const BOB_GATEWAY_BASE_URL = 'https://gateway-api-mainnet.gobob.xyz';
+// Chain name strings expected by the BOB Gateway API
+// https://gateway-api-mainnet.gobob.xyz/v2/get-routes
+export const chainIdToBobGatewayChainName = {
+    [arbitrumChainId]: 'arbitrum',
+    [avalancheChainId]: 'avalanche',
+    [baseChainId]: 'base',
+    [berachainChainId]: 'bera',
+    [btcChainId]: 'bitcoin',
+    [bobChainId]: 'bob',
+    [bscChainId]: 'bsc',
+    [ethChainId]: 'ethereum',
+    [seiChainId]: 'sei',
+    [sonicChainId]: 'sonic',
+    [unichainChainId]: 'unichain',
+};
+export const bobGatewayChainNameToChainId = Object.fromEntries(Object.entries(chainIdToBobGatewayChainName).map(([chainId, chainName]) => [chainName, chainId]));
+export const DUMMY_EVM_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+export const DUMMY_BTC_ADDRESS = 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq';
+export const BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = '350000'; // EVM→EVM
+export const BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = '550000'; // EVM→BTC
+export const BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = '200'; // BTC→EVM
+// https://docs.gobob.xyz/api-reference/v2/get-a-gateway-quote#parameter-slippage
+export const decimalSlippageToBobBps = (slippageDecimal) => {
+    return String(Math.round(parseFloat(slippageDecimal) * 10_000));
+};

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

@@ -0,0 +1,49 @@
+import type { GatewayOrderStatusV2, GatewayQuoteV2, GetQuoteParams } from '@gobob/bob-sdk';
+import { GatewaySDK } from '@gobob/bob-sdk';
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { GetTradeQuoteInput, QuoteFeeData, SwapErrorRight, SwapperConfig, SwapperDeps } from '../../../types.js';
+import type { BobGatewayMetadata } from '../types.js';
+import type { BobGatewayChainName } from './constants.js';
+export declare const getBobGatewayClient: (config: SwapperConfig) => GatewaySDK;
+export declare const assetIdToBobGatewayToken: (assetId: string) => string;
+export declare const getBobGatewayAffiliates: (affiliateBps: string) => GetQuoteParams['affiliates'];
+export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }: {
+    config: SwapperConfig;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellChainName: BobGatewayChainName;
+    buyChainName: BobGatewayChainName;
+    sender: string | undefined;
+    recipient: string;
+    amount: string;
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+}) => Promise<Result<GatewayQuoteV2, SwapErrorRight>>;
+export declare const createBobGatewayOrderMetadata: (config: SwapperConfig, gatewayQuote: GatewayQuoteV2) => Promise<Result<BobGatewayMetadata, SwapErrorRight>>;
+export declare const registerBobGatewayTx: ({ config, orderId, txHash, sellAsset, buyAsset, }: {
+    config: SwapperConfig;
+    orderId: string;
+    txHash: string;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Promise<void>;
+export declare const getBobGatewayQuoteFeeData: (input: GetTradeQuoteInput, { assertGetUtxoChainAdapter, assertGetEvmChainAdapter }: SwapperDeps, orderMetadata: BobGatewayMetadata) => Promise<Result<Omit<QuoteFeeData, 'protocolFees'>, SwapErrorRight>>;
+export declare const getBobGatewayRateNetworkFeeCryptoBaseUnit: (quote: GatewayQuoteV2, sellAsset: Asset, { assertGetEvmChainAdapter, assertGetUtxoChainAdapter }: SwapperDeps) => Promise<string | undefined>;
+export declare const mapBobGatewayOrderStatusToTxStatus: (status: GatewayOrderStatusV2) => TxStatus;
+export declare const parseBobGatewayQuote: (quote: GatewayQuoteV2, buyAsset: Asset, assetsById: AssetsByIdPartial) => {
+    buyAmountBeforeFeesCryptoBaseUnit: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    protocolFees: Partial<Record<AssetId, import("../../../types.js").ProtocolFee>>;
+    estimatedExecutionTimeMs: number | undefined;
+};
+export declare const getBobGatewayAllowanceContract: (quote: GatewayQuoteV2, sellAsset: Asset) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellChainName: BobGatewayChainName;
+    buyChainName: BobGatewayChainName;
+}, SwapErrorRight>;