@shapeshiftoss/swapper 17.7.3 → 17.8.0

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

@@ -1,30 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchBebopSolanaPrice = exports.fetchBebopSolanaQuote = exports.fetchBebopPrice = exports.fetchBebopQuote = void 0;
+exports.fetchBebopSolanaQuote = exports.fetchBebopQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
 const viem_1 = require("viem");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
 const types_2 = require("../types");
 const bebopService_1 = require("./bebopService");
-const helpers_1 = require("./helpers/helpers");
+const helpers_2 = require("./helpers/helpers");
 const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
-        const sellToken = (0, helpers_1.assetIdToBebopToken)(sellAsset.assetId);
-        const buyToken = (0, helpers_1.assetIdToBebopToken)(buyAsset.assetId);
+        const sellToken = (0, helpers_2.assetIdToBebopToken)(sellAsset.assetId);
+        const buyToken = (0, helpers_2.assetIdToBebopToken)(buyAsset.assetId);
         const checksummedTakerAddress = (0, viem_1.getAddress)(takerAddress);
         const checksummedReceiverAddress = (0, viem_1.getAddress)(receiverAddress);
         const chainName = types_2.chainIdToBebopChain[sellAsset.chainId];
         const sellAmountFormatted = (0, utils_1.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 = (0, utils_1.bn)(slippageTolerancePercentageDecimal ?? 0.003)
-            .times(100)
-            .toNumber();
-        const url = `https://api.bebop.xyz/router/${chainName}/v1/quote`;
-        const params = new URLSearchParams({
+        const slippagePercentage = (0, utils_1.bn)(slippageTolerancePercentageDecimal).times(100).toNumber();
+        const baseParams = {
             sell_tokens: sellToken,
             buy_tokens: buyToken,
             sell_amounts: sellAmountFormatted,
@@ -35,38 +31,46 @@ const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtoco
             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', (0, viem_1.getAddress)((0, helpers_1.getTreasuryAddressFromChainId)(buyAsset.chainId)));
+            // PMM attributes the fee off-chain via source
+            pmmParams.set('fee', affiliateBps);
         }
-        const bebopService = (0, bebopService_1.bebopServiceFactory)({ apiKey });
-        const maybeResponse = await bebopService.get(`${url}?${params}`);
-        if (maybeResponse.isErr()) {
+        const service = (0, bebopService_1.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 (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
                 message: 'Failed to fetch quote from Bebop',
-                cause: maybeResponse.unwrapErr().cause,
+                cause: maybeResponses[0].unwrapErr().cause,
                 code: types_1.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 (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: 'No routes available',
+                message: 'No route available',
                 code: types_1.TradeQuoteError.NoRouteFound,
             }));
         }
-        if (!response.data.bestPrice) {
-            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: 'No best price route specified',
-                code: types_1.TradeQuoteError.InvalidResponse,
-            }));
-        }
-        return (0, monads_1.Ok)(response.data);
+        const getBuyAmount = (quote) => (0, utils_1.bnOrZero)(Object.values(quote.buyTokens)[0]?.amount);
+        const bestQuote = quotes.reduce((best, quote) => getBuyAmount(quote).gt(getBuyAmount(best)) ? quote : best);
+        return (0, monads_1.Ok)(bestQuote);
     }
     catch (error) {
         return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
@@ -77,29 +81,20 @@ const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtoco
     }
 };
 exports.fetchBebopQuote = fetchBebopQuote;
-const fetchBebopPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }) => {
-    const address = receiveAddress || types_2.BEBOP_DUMMY_ADDRESS;
-    return (0, exports.fetchBebopQuote)({
-        buyAsset,
-        sellAsset,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        takerAddress: address,
-        receiverAddress: address,
-        slippageTolerancePercentageDecimal: '0.01',
-        affiliateBps,
-        apiKey,
-    });
-};
-exports.fetchBebopPrice = fetchBebopPrice;
 const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
-        const sellToken = (0, helpers_1.assetIdToBebopSolanaToken)(sellAsset.assetId);
-        const buyToken = (0, helpers_1.assetIdToBebopSolanaToken)(buyAsset.assetId);
+        // 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 === caip_1.solAssetId) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Bebop Solana cannot sell native SOL',
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const sellToken = (0, helpers_2.assetIdToBebopSolanaToken)(sellAsset.assetId);
+        const buyToken = (0, helpers_2.assetIdToBebopSolanaToken)(buyAsset.assetId);
         const sellAmountFormatted = (0, utils_1.bn)(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0);
-        const slippagePercentage = (0, utils_1.bn)(slippageTolerancePercentageDecimal ?? 0.003)
-            .times(100)
-            .toNumber();
-        const url = 'https://api.bebop.xyz/pmm/solana/v3/quote';
+        const slippagePercentage = (0, utils_1.bn)(slippageTolerancePercentageDecimal).times(100).toNumber();
         const params = new URLSearchParams({
             sell_tokens: sellToken,
             buy_tokens: buyToken,
@@ -115,8 +110,7 @@ const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingP
         if (affiliateBps && affiliateBps !== '0') {
             params.set('fee', affiliateBps);
         }
-        const bebopService = (0, bebopService_1.bebopServiceFactory)({ apiKey });
-        const maybeResponse = await bebopService.get(`${url}?${params}`);
+        const maybeResponse = await (0, bebopService_1.bebopServiceFactory)({ apiKey }).get('https://api.bebop.xyz/pmm/solana/v3/quote', { params });
         if (maybeResponse.isErr()) {
             const err = maybeResponse.unwrapErr();
             return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
@@ -138,19 +132,6 @@ const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingP
                 code: types_1.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 (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: `Bebop Solana quote contains AMM routing (${response.data.makers.join(', ')}), which produces malformed txs`,
-                code: types_1.TradeQuoteError.NoRouteFound,
-            }));
-        }
         return (0, monads_1.Ok)(response.data);
     }
     catch (error) {
@@ -162,17 +143,3 @@ const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingP
     }
 };
 exports.fetchBebopSolanaQuote = fetchBebopSolanaQuote;
-const fetchBebopSolanaPrice = ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, affiliateBps, apiKey, }) => {
-    const address = receiveAddress || types_2.BEBOP_SOLANA_DUMMY_ADDRESS;
-    return (0, exports.fetchBebopSolanaQuote)({
-        buyAsset,
-        sellAsset,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        takerAddress: address,
-        receiverAddress: address,
-        slippageTolerancePercentageDecimal: '0.01',
-        affiliateBps,
-        apiKey,
-    });
-};
-exports.fetchBebopSolanaPrice = fetchBebopSolanaPrice;

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

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

package/dist/cjs/swappers/BobGatewaySwapper/BobGatewaySwapper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bobGatewaySwapper = void 0;
+const utils_1 = require("../../utils");
+exports.bobGatewaySwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => signAndBroadcastTransaction(txToSign),
+};

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

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

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bobGatewayApi = void 0;
+const bob_sdk_1 = require("@gobob/bob-sdk");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const utils_2 = require("../../utils");
+const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
+const getTradeRate_1 = require("./swapperApi/getTradeRate");
+const helpers_1 = require("./utils/helpers");
+const registeredSwapIds = new Set();
+exports.bobGatewayApi = {
+    getTradeRate: async (input, deps) => {
+        return (await (0, getTradeRate_1.getBobGatewayTradeRate)(input, deps)).map(tradeRate => [tradeRate]);
+    },
+    getTradeQuote: async (input, deps) => {
+        return (await (0, getTradeQuote_1.getBobGatewayTradeQuote)(input, deps)).map(tradeQuote => [tradeQuote]);
+    },
+    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = (0, utils_2.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = (0, utils_2.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = (0, utils_2.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 chain_adapters_1.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 = (0, utils_1.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = (0, utils_2.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 chain_adapters_1.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 (0, helpers_1.registerBobGatewayTx)({
+                    config,
+                    orderId,
+                    txHash,
+                    sellAsset: swap.sellAsset,
+                    buyAsset: swap.buyAsset,
+                });
+                registeredSwapIds.add(swap.id);
+            }
+            catch { }
+        }
+        let orderInfo;
+        try {
+            orderInfo = await (0, helpers_1.getBobGatewayClient)(config).getOrder(orderId);
+        }
+        catch (err) {
+            if ((0, bob_sdk_1.isGatewayError)(err)) {
+                if (err.code === 'ORDER_NOT_FOUND') {
+                    return {
+                        buyTxHash: undefined,
+                        status: unchained_client_1.TxStatus.Unknown,
+                        message: 'Waiting for deposit...',
+                    };
+                }
+            }
+            throw err;
+        }
+        const status = (0, helpers_1.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/cjs/swappers/BobGatewaySwapper/index.d.ts

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

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

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bobGatewaySwapper = exports.bobGatewayApi = void 0;
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "bobGatewayApi", { enumerable: true, get: function () { return endpoints_1.bobGatewayApi; } });
+var BobGatewaySwapper_1 = require("./BobGatewaySwapper");
+Object.defineProperty(exports, "bobGatewaySwapper", { enumerable: true, get: function () { return BobGatewaySwapper_1.bobGatewaySwapper; } });
+__exportStar(require("./utils/constants"), exports);

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

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

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBobGatewayTradeQuote = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const helpers_1 = require("../utils/helpers");
+const getBobGatewayTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    if (!sendAddress) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: '[BobGateway] sendAddress is required for quote',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!receiveAddress) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: '[BobGateway] receiveAddress is required for quote',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.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 = (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? sendAddress : undefined;
+    const maybeQuote = await (0, helpers_1.getBobGatewayQuote)({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient: receiveAddress,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return (0, monads_1.Err)(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const maybeOrderMetadata = await (0, helpers_1.createBobGatewayOrderMetadata)(config, quote);
+    if (maybeOrderMetadata.isErr())
+        return (0, monads_1.Err)(maybeOrderMetadata.unwrapErr());
+    const orderMetadata = maybeOrderMetadata.unwrap();
+    const maybeFeeData = await (0, helpers_1.getBobGatewayQuoteFeeData)(input, deps, orderMetadata);
+    if (maybeFeeData.isErr())
+        return (0, monads_1.Err)(maybeFeeData.unwrapErr());
+    const feeData = maybeFeeData.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = (0, helpers_1.parseBobGatewayQuote)(quote, buyAsset, deps.assetsById);
+    const rate = (0, utils_1.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = (0, helpers_1.getBobGatewayAllowanceContract)(quote, sellAsset);
+    const tradeQuote = {
+        id: (0, uuid_1.v4)(),
+        quoteOrRate: 'quote',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: types_1.SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: { ...feeData, protocolFees },
+                rate,
+                source: types_1.SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+                bobSpecific: orderMetadata,
+            },
+        ],
+    };
+    return (0, monads_1.Ok)(tradeQuote);
+};
+exports.getBobGatewayTradeQuote = getBobGatewayTradeQuote;

package/dist/cjs/swappers/BobGatewaySwapper/swapperApi/getTradeRate.d.ts

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

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBobGatewayTradeRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+const getBobGatewayTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    const recipient = receiveAddress ?? (buyAsset.chainId === caip_1.btcChainId ? constants_1.DUMMY_BTC_ADDRESS : constants_1.DUMMY_EVM_ADDRESS);
+    const sender = sellAsset.chainId === caip_1.btcChainId ? undefined : constants_1.DUMMY_EVM_ADDRESS;
+    const maybeQuote = await (0, helpers_1.getBobGatewayQuote)({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return (0, monads_1.Err)(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = (0, helpers_1.parseBobGatewayQuote)(quote, buyAsset, deps.assetsById);
+    const rate = (0, utils_1.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = (0, helpers_1.getBobGatewayAllowanceContract)(quote, sellAsset);
+    const networkFeeCryptoBaseUnit = await (0, helpers_1.getBobGatewayRateNetworkFeeCryptoBaseUnit)(quote, sellAsset, deps);
+    const tradeRate = {
+        id: (0, uuid_1.v4)(),
+        quoteOrRate: 'rate',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: types_1.SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: {
+                    networkFeeCryptoBaseUnit,
+                    protocolFees,
+                },
+                rate,
+                source: types_1.SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+            },
+        ],
+    };
+    return (0, monads_1.Ok)(tradeRate);
+};
+exports.getBobGatewayTradeRate = getBobGatewayTradeRate;

package/dist/cjs/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/cjs/swappers/BobGatewaySwapper/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/swappers/BobGatewaySwapper/utils/constants.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimalSlippageToBobBps = exports.BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = exports.BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = exports.BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = exports.DUMMY_BTC_ADDRESS = exports.DUMMY_EVM_ADDRESS = exports.bobGatewayChainNameToChainId = exports.chainIdToBobGatewayChainName = exports.BOB_GATEWAY_BASE_URL = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+exports.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
+exports.chainIdToBobGatewayChainName = {
+    [caip_1.arbitrumChainId]: 'arbitrum',
+    [caip_1.avalancheChainId]: 'avalanche',
+    [caip_1.baseChainId]: 'base',
+    [caip_1.berachainChainId]: 'bera',
+    [caip_1.btcChainId]: 'bitcoin',
+    [caip_1.bobChainId]: 'bob',
+    [caip_1.bscChainId]: 'bsc',
+    [caip_1.ethChainId]: 'ethereum',
+    [caip_1.seiChainId]: 'sei',
+    [caip_1.sonicChainId]: 'sonic',
+    [caip_1.unichainChainId]: 'unichain',
+};
+exports.bobGatewayChainNameToChainId = Object.fromEntries(Object.entries(exports.chainIdToBobGatewayChainName).map(([chainId, chainName]) => [chainName, chainId]));
+exports.DUMMY_EVM_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+exports.DUMMY_BTC_ADDRESS = 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq';
+exports.BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = '350000'; // EVM→EVM
+exports.BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = '550000'; // EVM→BTC
+exports.BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = '200'; // BTC→EVM
+// https://docs.gobob.xyz/api-reference/v2/get-a-gateway-quote#parameter-slippage
+const decimalSlippageToBobBps = (slippageDecimal) => {
+    return String(Math.round(parseFloat(slippageDecimal) * 10_000));
+};
+exports.decimalSlippageToBobBps = decimalSlippageToBobBps;