@shapeshiftoss/swapper 17.7.2 → 17.8.0

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;

package/dist/cjs/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';
+import type { BobGatewayMetadata } from '../types';
+import type { BobGatewayChainName } from './constants';
+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").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>;

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

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidTrade = exports.getBobGatewayAllowanceContract = exports.parseBobGatewayQuote = exports.mapBobGatewayOrderStatusToTxStatus = exports.getBobGatewayRateNetworkFeeCryptoBaseUnit = exports.getBobGatewayQuoteFeeData = exports.registerBobGatewayTx = exports.createBobGatewayOrderMetadata = exports.getBobGatewayQuote = exports.getBobGatewayAffiliates = exports.assetIdToBobGatewayToken = exports.getBobGatewayClient = void 0;
+const bob_sdk_1 = require("@gobob/bob-sdk");
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const viem_1 = require("viem");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_2 = require("./constants");
+const getBobGatewayClient = (config) => {
+    return new bob_sdk_1.GatewaySDK({ basePath: constants_2.BOB_GATEWAY_BASE_URL, apiKey: config.VITE_BOB_GATEWAY_API_KEY });
+};
+exports.getBobGatewayClient = getBobGatewayClient;
+const assetIdToBobGatewayToken = (assetId) => {
+    // BOB Gateway uses the zero address as the token address for native assets
+    if (!(0, utils_1.isToken)(assetId))
+        return viem_1.zeroAddress;
+    return (0, caip_1.fromAssetId)(assetId).assetReference;
+};
+exports.assetIdToBobGatewayToken = assetIdToBobGatewayToken;
+const getBobGatewayAffiliates = (affiliateBps) => {
+    const bps = (0, utils_1.bnOrZero)(affiliateBps);
+    if (!bps.isFinite() || bps.lte(0))
+        return undefined;
+    const affiliateAddress = (0, helpers_1.getTreasuryAddressFromChainId)(caip_1.ethChainId);
+    return [{ address: (0, viem_1.getAddress)(affiliateAddress), bps: bps.toNumber() }];
+};
+exports.getBobGatewayAffiliates = getBobGatewayAffiliates;
+const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }) => {
+    const slippage = (0, constants_2.decimalSlippageToBobBps)(slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.BobGateway));
+    try {
+        const quote = await (0, exports.getBobGatewayClient)(config).getQuote({
+            fromChain: sellChainName,
+            toChain: buyChainName,
+            fromToken: (0, exports.assetIdToBobGatewayToken)(sellAsset.assetId),
+            toToken: (0, exports.assetIdToBobGatewayToken)(buyAsset.assetId),
+            fromUserAddress: sender,
+            toUserAddress: recipient,
+            amount,
+            maxSlippage: Number(slippage),
+            affiliates: (0, exports.getBobGatewayAffiliates)(affiliateBps),
+        });
+        return (0, monads_1.Ok)(quote);
+    }
+    catch (err) {
+        if ((0, bob_sdk_1.isGatewayError)(err)) {
+            switch (err.code) {
+                case bob_sdk_1.GatewayErrorCode.QuoteAmountTooLow:
+                    return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({
+                        minAmountCryptoBaseUnit: err.details.minimum,
+                        assetId: sellAsset.assetId,
+                    }));
+                case bob_sdk_1.GatewayErrorCode.UnableToCoverFees:
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: '[BobGateway] sell amount does not cover fees',
+                        code: types_1.TradeQuoteError.SellAmountBelowTradeFee,
+                        cause: err,
+                    }));
+                case bob_sdk_1.GatewayErrorCode.NoRoute:
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: '[BobGateway] no route found for trade pair',
+                        code: types_1.TradeQuoteError.NoRouteFound,
+                        cause: err,
+                    }));
+                case bob_sdk_1.GatewayErrorCode.DisabledChain:
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: '[BobGateway] trading is temporarily halted for this chain',
+                        code: types_1.TradeQuoteError.TradingHalted,
+                        cause: err,
+                    }));
+                default:
+                    break;
+            }
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[BobGateway] failed to fetch quote',
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getBobGatewayQuote = getBobGatewayQuote;
+const createBobGatewayOrderMetadata = async (config, gatewayQuote) => {
+    try {
+        const orderResponse = await (0, exports.getBobGatewayClient)(config).api.createOrderV2({
+            gatewayQuoteV2: gatewayQuote,
+        });
+        // onramp (BTC→EVM)
+        if ('onramp' in orderResponse) {
+            return (0, monads_1.Ok)({
+                orderId: orderResponse.onramp.orderId,
+                utxoTx: {
+                    depositAddress: orderResponse.onramp.address,
+                    opReturnData: orderResponse.onramp.opReturnData ?? undefined,
+                },
+            });
+        }
+        // offramp (EVM→BTC) and tokenSwap (EVM→EVM) orders share the same tx shape
+        const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+        return (0, monads_1.Ok)({
+            orderId: order.orderId,
+            evmTx: {
+                to: order.tx.to,
+                data: order.tx.data,
+                value: order.tx.value,
+                chain: order.tx.chain,
+            },
+        });
+    }
+    catch (err) {
+        if ((0, bob_sdk_1.isGatewayError)(err) && err.code === bob_sdk_1.GatewayErrorCode.InsufficientConfirmedFunds) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: '[BobGateway] insufficient confirmed balance',
+                code: types_1.TradeQuoteError.InsufficientFundsUnconfirmed,
+                cause: err,
+            }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[BobGateway] failed to create order',
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.createBobGatewayOrderMetadata = createBobGatewayOrderMetadata;
+const registerBobGatewayTx = async ({ config, orderId, txHash, sellAsset, buyAsset, }) => {
+    const registerTxV2 = (() => {
+        // BTC→EVM
+        if (constants_2.chainIdToBobGatewayChainName[sellAsset.chainId] === 'bitcoin') {
+            return { onramp: { orderId, bitcoinTxid: txHash } };
+        }
+        // EVM→BTC
+        if (constants_2.chainIdToBobGatewayChainName[buyAsset.chainId] === 'bitcoin') {
+            return { offramp: { orderId, evmTxhash: txHash } };
+        }
+        // EVM→EVM
+        return { tokenSwap: { orderId, evmTxhash: txHash } };
+    })();
+    await (0, exports.getBobGatewayClient)(config).api.registerTxV2({ registerTxV2 });
+};
+exports.registerBobGatewayTx = registerBobGatewayTx;
+const getBobGatewayQuoteFeeData = async (input, { assertGetUtxoChainAdapter, assertGetEvmChainAdapter }, orderMetadata) => {
+    const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    try {
+        if (orderMetadata.utxoTx && 'xpub' in input) {
+            const { depositAddress, opReturnData } = orderMetadata.utxoTx;
+            const { fast } = await assertGetUtxoChainAdapter(sellAsset.chainId).getFeeData({
+                to: depositAddress,
+                value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                chainSpecific: { pubkey: input.xpub, opReturnData },
+                sendMax: false,
+            });
+            return (0, monads_1.Ok)({
+                networkFeeCryptoBaseUnit: fast.txFee,
+                chainSpecific: { satsPerByte: fast.chainSpecific.satoshiPerByte },
+            });
+        }
+        if (orderMetadata.evmTx && input.sendAddress && 'supportsEIP1559' in input) {
+            const { to, data, value } = orderMetadata.evmTx;
+            const { networkFeeCryptoBaseUnit } = await chain_adapters_1.evm.getFees({
+                adapter: assertGetEvmChainAdapter(sellAsset.chainId),
+                to,
+                data,
+                value,
+                from: input.sendAddress,
+                supportsEIP1559: input.supportsEIP1559,
+            });
+            return (0, monads_1.Ok)({ networkFeeCryptoBaseUnit });
+        }
+        throw new Error('[BobGateway] invalid quote');
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[BobGateway] failed to estimate network fee',
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getBobGatewayQuoteFeeData = getBobGatewayQuoteFeeData;
+const getBobGatewayRateNetworkFeeCryptoBaseUnit = async (quote, sellAsset, { assertGetEvmChainAdapter, assertGetUtxoChainAdapter }) => {
+    try {
+        if ('onramp' in quote) {
+            const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+            const { fast } = await adapter.httpProvider.getNetworkFees();
+            if (!fast?.satsPerKiloByte)
+                return undefined;
+            const satsPerByte = Math.max(1, Math.ceil(fast.satsPerKiloByte / 1000));
+            return (0, utils_1.bnOrZero)(satsPerByte).times(constants_2.BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE).toFixed(0);
+        }
+        const defaultGasLimit = 'offramp' in quote
+            ? constants_2.BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT
+            : constants_2.BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT;
+        const { average } = await assertGetEvmChainAdapter(sellAsset.chainId).getGasFeeData();
+        const feePerGas = (0, utils_1.bnOrZero)(average.maxFeePerGas).gt(0) ? average.maxFeePerGas : average.gasPrice;
+        return (0, utils_1.bnOrZero)(defaultGasLimit).times((0, utils_1.bnOrZero)(feePerGas)).toFixed(0);
+    }
+    catch {
+        return undefined;
+    }
+};
+exports.getBobGatewayRateNetworkFeeCryptoBaseUnit = getBobGatewayRateNetworkFeeCryptoBaseUnit;
+const mapBobGatewayOrderStatusToTxStatus = (status) => {
+    if ('inProgress' in status)
+        return unchained_client_1.TxStatus.Pending;
+    if ('success' in status)
+        return unchained_client_1.TxStatus.Confirmed;
+    if ('failed' in status)
+        return unchained_client_1.TxStatus.Failed;
+    if ('refunded' in status)
+        return unchained_client_1.TxStatus.Failed;
+    return unchained_client_1.TxStatus.Unknown;
+};
+exports.mapBobGatewayOrderStatusToTxStatus = mapBobGatewayOrderStatusToTxStatus;
+const bobGatewayFeeToAssetId = (fee) => {
+    const chainId = constants_2.bobGatewayChainNameToChainId[fee.chain];
+    if (!chainId)
+        return;
+    if (fee.address.toLowerCase() === viem_1.zeroAddress)
+        return (0, utils_1.chainIdToFeeAssetId)(chainId);
+    return (0, caip_1.toAssetId)({
+        chainId,
+        assetNamespace: caip_1.ASSET_NAMESPACE.erc20,
+        assetReference: fee.address,
+    });
+};
+const parseBobGatewayQuote = (quote, buyAsset, assetsById) => {
+    const { outputAmount, estimatedTimeInSecs, fees } = (() => {
+        if ('onramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, fees } = quote.onramp;
+            return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+        }
+        if ('offramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, feeBreakdown } = quote.offramp;
+            const { affiliateFee, inclusionFee, protocolFee, solverFee } = feeBreakdown;
+            return {
+                outputAmount,
+                estimatedTimeInSecs,
+                fees: [affiliateFee, inclusionFee, protocolFee, solverFee],
+            };
+        }
+        const { outputAmount, estimatedTimeInSecs, fees } = quote.tokenSwap;
+        return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+    })();
+    const protocolFees = fees.reduce((acc, fee) => {
+        const amountCryptoBaseUnit = (0, utils_1.bnOrZero)(fee.amount);
+        if (amountCryptoBaseUnit.lte(0))
+            return acc;
+        const assetId = bobGatewayFeeToAssetId(fee);
+        if (!assetId)
+            return acc;
+        const asset = assetId === buyAsset.assetId ? buyAsset : assetsById[assetId];
+        if (!asset)
+            return acc;
+        acc[assetId] = {
+            amountCryptoBaseUnit: (0, utils_1.bnOrZero)(acc[assetId]?.amountCryptoBaseUnit)
+                .plus(amountCryptoBaseUnit)
+                .toFixed(),
+            asset,
+            requiresBalance: false,
+        };
+        return acc;
+    }, {});
+    // buyAmountBeforeFees is denominated in the buy asset, so only add back buy-asset-denominated fees
+    const buyAssetFeeCryptoBaseUnit = (0, utils_1.bnOrZero)(protocolFees[buyAsset.assetId]?.amountCryptoBaseUnit);
+    return {
+        buyAmountBeforeFeesCryptoBaseUnit: buyAssetFeeCryptoBaseUnit
+            .plus((0, utils_1.bnOrZero)(outputAmount.amount))
+            .toFixed(),
+        buyAmountAfterFeesCryptoBaseUnit: outputAmount.amount,
+        protocolFees,
+        estimatedExecutionTimeMs: typeof estimatedTimeInSecs === 'number' ? estimatedTimeInSecs * 1000 : undefined,
+    };
+};
+exports.parseBobGatewayQuote = parseBobGatewayQuote;
+const getBobGatewayAllowanceContract = (quote, sellAsset) => {
+    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId))
+        return '';
+    if (!(0, utils_1.contractAddressOrUndefined)(sellAsset.assetId))
+        return '';
+    if ('offramp' in quote)
+        return quote.offramp.txTo;
+    if ('tokenSwap' in quote)
+        return quote.tokenSwap.txTo;
+    return '';
+};
+exports.getBobGatewayAllowanceContract = getBobGatewayAllowanceContract;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellChainName = constants_2.chainIdToBobGatewayChainName[sellAsset.chainId];
+    const buyChainName = constants_2.chainIdToBobGatewayChainName[buyAsset.chainId];
+    if (!sellChainName) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[BobGateway] unsupported sell chain: ${sellAsset.chainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!buyChainName) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[BobGateway] unsupported buy chain: ${buyAsset.chainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    return (0, monads_1.Ok)({ sellChainName, buyChainName });
+};
+exports.assertValidTrade = assertValidTrade;

package/dist/cjs/swappers/ButterSwap/swapperApi/checkTradeStatus.test.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const caip_1 = require("@shapeshiftoss/caip");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
@@ -155,7 +145,7 @@ vitest_1.vi.mock('../xhr', () => ({
     (0, vitest_1.it)('should proceed to bridge polling for cross-chain swaps', async () => {
         const mockBridgeInfo = {
             id: 12345,
-            state: 1, // Confirmed
+            state: 1,
             toHash: 'dest-tx',
             relayerHash: 'relayer-tx',
             relayerChain: { scanUrl: 'https://scan.url' },
@@ -199,7 +189,7 @@ vitest_1.vi.mock('../xhr', () => ({
             txHash: mockTxHash,
             chainId: mockEvmChainId,
             address: mockAddress,
-            swap: undefined, // No swap data
+            swap: undefined,
             assertGetEvmChainAdapter: mockAssertGetEvmChainAdapter,
             assertGetSolanaChainAdapter: mockAssertGetSolanaChainAdapter,
             fetchIsSmartContractAddressQuery: mockFetchIsSmartContractAddressQuery,

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

@@ -74,7 +74,7 @@ const getTradeQuote = async (input, _deps) => {
     const buildTxResult = await (0, xhr_1.fetchTxData)({
         hash: route.hash,
         slippage,
-        from: sendAddress, // from (source chain address)
+        from: sendAddress,
         receiver: receiveAddress, // receiver (destination chain address)
     });
     if (buildTxResult.isErr())