@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBobGatewayStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const utxo_1 = require("../../../utils/utxo");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+async function getBobGatewayStepData(args) {
+    const { input, quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, deps } = args;
+    const { chainNamespace } = (0, caip_1.fromChainId)(sellAsset.chainId);
+    // Rates estimate off the quote shape; quotes resolve the executable order once up front
+    const maybeResolved = await (async () => {
+        if (args.type === 'rate')
+            return (0, monads_1.Ok)({ type: 'rate' });
+        const maybeOrderResponse = await (0, helpers_1.createBobGatewayOrder)(deps.config, quote);
+        if (maybeOrderResponse.isErr())
+            return (0, monads_1.Err)(maybeOrderResponse.unwrapErr());
+        return (0, monads_1.Ok)({
+            type: 'quote',
+            orderResponse: maybeOrderResponse.unwrap(),
+            from: args.from,
+        });
+    })();
+    if (maybeResolved.isErr())
+        return (0, monads_1.Err)(maybeResolved.unwrapErr());
+    const resolved = maybeResolved.unwrap();
+    switch (chainNamespace) {
+        // BTC sells (onramp BTC -> EVM/TRON)
+        case caip_1.CHAIN_NAMESPACE.Utxo: {
+            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+            const pubkey = 'xpub' in input ? input.xpub : undefined;
+            if (resolved.type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    try {
+                        const { networkFeeCryptoBaseUnit } = await (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+                            adapter,
+                            pubkey,
+                            to: input.sendAddress ?? utxo_1.UTXO_PLACEHOLDER_ADDRESS,
+                            value: sellAmountCryptoBaseUnit,
+                        });
+                        return networkFeeCryptoBaseUnit;
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            const { orderResponse } = resolved;
+            if (!('onramp' in orderResponse))
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const transactionData = {
+                type: 'utxo',
+                to: orderResponse.onramp.address,
+                opReturnData: orderResponse.onramp.opReturnData ?? undefined,
+                value: sellAmountCryptoBaseUnit,
+            };
+            try {
+                const { networkFeeCryptoBaseUnit } = await (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    pubkey,
+                    to: transactionData.to,
+                    value: sellAmountCryptoBaseUnit,
+                    opReturnData: transactionData.opReturnData,
+                });
+                const stepData = {
+                    orderId: orderResponse.onramp.orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (err) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getBobGatewayStepData', err));
+            }
+        }
+        // EVM sells (offramp EVM → BTC, or tokenSwap EVM → Tron)
+        case caip_1.CHAIN_NAMESPACE.Evm: {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            if (resolved.type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    if (!('offramp' in quote) && !('tokenSwap' in quote))
+                        return;
+                    try {
+                        const gasLimit = 'offramp' in quote
+                            ? constants_1.BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT
+                            : constants_1.BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT;
+                        return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                            adapter,
+                            supportsEIP1559: 'supportsEIP1559' in input ? input.supportsEIP1559 : false,
+                            gasLimit,
+                        });
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            const { orderResponse, from } = resolved;
+            if (!('offramp' in orderResponse) && !('tokenSwap' in orderResponse))
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+            if (order.tx.type !== 'evm')
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const { tx, orderId } = order;
+            if (!('supportsEIP1559' in input))
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const transactionData = {
+                type: 'evm',
+                chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+            };
+            try {
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559: input.supportsEIP1559,
+                    stateOverride: {
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                    },
+                });
+                const stepData = {
+                    orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (err) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getBobGatewayStepData', err));
+            }
+        }
+        // Tron sells (offramp Tron → BTC, or tokenSwap TRON → EVM)
+        case caip_1.CHAIN_NAMESPACE.Tron: {
+            const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+            const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+            if (resolved.type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    try {
+                        if (!('offramp' in quote) && !('tokenSwap' in quote))
+                            return;
+                        const order = 'offramp' in quote ? quote.offramp : quote.tokenSwap;
+                        const { fast } = await adapter.getFeeData({
+                            to: (0, helpers_1.toTronBase58)(order.txTo),
+                            value: order.inputAmount.amount,
+                            chainSpecific: { contractAddress },
+                        });
+                        return fast.txFee;
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            const { orderResponse, from } = resolved;
+            if (!('offramp' in orderResponse) && !('tokenSwap' in orderResponse))
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+            if (order.tx.type !== 'tron')
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getBobGatewayStepData'));
+            const { tx, orderId } = order;
+            const transactionData = {
+                type: 'tron',
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+            };
+            try {
+                const { fast } = await adapter.getFeeData({
+                    to: (0, helpers_1.toTronBase58)(tx.to),
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from, contractAddress },
+                });
+                const stepData = {
+                    orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit: fast.txFee,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (err) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getBobGatewayStepData', err));
+            }
+        }
+        default:
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[BobGateway] unsupported chain namespace: ${chainNamespace}`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+    }
+}
+exports.getBobGatewayStepData = getBobGatewayStepData;

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

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { BobGatewayTradeQuoteInput, BobGatewayTradeRateInput } from '../types';
+import type { GetBobGatewayStepDataArgs } from './getBobGatewayStepData';
+type BobGatewayTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetBobGatewayStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getBobGatewayTradeContext: ({ input, deps, sender, recipient, }: {
+    input: BobGatewayTradeQuoteInput | BobGatewayTradeRateInput;
+    deps: SwapperDeps;
+    sender: string | undefined;
+    recipient: string;
+}) => Promise<Result<BobGatewayTradeContext, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBobGatewayTradeContext = 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("./helpers");
+const getBobGatewayTradeContext = async ({ input, deps, sender, recipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    const maybeQuote = await (0, helpers_1.getBobGatewayQuote)({
+        config: deps.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);
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.SwapperName.BobGateway,
+        },
+        stepCommon: {
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            rate,
+            source: types_1.SwapperName.BobGateway,
+            buyAsset,
+            sellAsset,
+            allowanceContract,
+            estimatedExecutionTimeMs,
+        },
+        protocolFees,
+        stepDataArgs: {
+            quote,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            spenderAddress: (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? allowanceContract : '',
+            deps,
+        },
+    });
+};
+exports.getBobGatewayTradeContext = getBobGatewayTradeContext;

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

@@ -0,0 +1,48 @@
+import type { GatewayOrderStatusV3, GatewayQuoteV3, GetQuoteParams } from '@gobob/bob-sdk';
+import { GatewaySDK } from '@gobob/bob-sdk';
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
+import type { BobGatewayChainName } from './constants';
+export declare const dummyAddressForChainId: (chainId: ChainId) => string;
+export declare const getBobGatewayClient: (config: SwapperConfig) => GatewaySDK;
+export declare const toTronBase58: (address: string) => string;
+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<GatewayQuoteV3, SwapErrorRight>>;
+export declare const createBobGatewayOrder: (config: SwapperConfig, quote: GatewayQuoteV3) => Promise<import("@sniptt/monads/build/result/result").ResOk<import("@gobob/bob-sdk").GatewayCreateOrderV3, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, 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 mapBobGatewayOrderStatusToTxStatus: (status: GatewayOrderStatusV3) => TxStatus;
+export declare const parseBobGatewayQuote: (quote: GatewayQuoteV3, buyAsset: Asset, assetsById: AssetsByIdPartial) => {
+    buyAmountBeforeFeesCryptoBaseUnit: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    protocolFees: Partial<Record<AssetId, import("../../../types").ProtocolFee>>;
+    estimatedExecutionTimeMs: number | undefined;
+};
+export declare const getBobGatewayAllowanceContract: (quote: GatewayQuoteV3, 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,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidTrade = exports.getBobGatewayAllowanceContract = exports.parseBobGatewayQuote = exports.mapBobGatewayOrderStatusToTxStatus = exports.registerBobGatewayTx = exports.createBobGatewayOrder = exports.getBobGatewayQuote = exports.getBobGatewayAffiliates = exports.assetIdToBobGatewayToken = exports.toTronBase58 = exports.getBobGatewayClient = exports.dummyAddressForChainId = 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 tronweb_1 = require("tronweb");
+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");
+const constants_2 = require("./constants");
+const dummyAddressForChainId = (chainId) => {
+    if (chainId === caip_1.btcChainId)
+        return constants_2.DUMMY_BTC_ADDRESS;
+    if (chainId === caip_1.tronChainId)
+        return constants_2.DUMMY_TRON_ADDRESS;
+    return constants_2.DUMMY_EVM_ADDRESS;
+};
+exports.dummyAddressForChainId = dummyAddressForChainId;
+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 toTronBase58 = (address) => {
+    if (address.startsWith('T'))
+        return address;
+    if (address.startsWith('0x'))
+        return tronweb_1.TronWeb.address.fromHex(address.slice(2));
+    return tronweb_1.TronWeb.address.fromHex(address);
+};
+exports.toTronBase58 = toTronBase58;
+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),
+            ownerAddress: sellChainName === 'bitcoin' ? recipient : sender,
+            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 createBobGatewayOrder = async (config, quote) => {
+    try {
+        const order = await (0, exports.getBobGatewayClient)(config).api.createOrderV3({ gatewayQuoteV3: quote });
+        return (0, monads_1.Ok)(order);
+    }
+    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.createBobGatewayOrder = createBobGatewayOrder;
+const registerBobGatewayTx = async ({ config, orderId, txHash, sellAsset, buyAsset, }) => {
+    const registerTxV3 = (() => {
+        const sellChainName = constants_2.chainIdToBobGatewayChainName[sellAsset.chainId];
+        // BTC→EVM
+        if (sellChainName === 'bitcoin') {
+            return { onramp: { orderId, bitcoinTxid: txHash } };
+        }
+        // EVM→BTC
+        if (constants_2.chainIdToBobGatewayChainName[buyAsset.chainId] === 'bitcoin') {
+            return { offramp: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
+        }
+        // EVM→EVM
+        return { tokenSwap: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
+    })();
+    await (0, exports.getBobGatewayClient)(config).api.registerTxV3({ registerTxV3 });
+};
+exports.registerBobGatewayTx = registerBobGatewayTx;
+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);
+    if (chainId === caip_1.tronChainId) {
+        return (0, caip_1.toAssetId)({
+            chainId,
+            assetNamespace: caip_1.ASSET_NAMESPACE.trc20,
+            assetReference: (0, exports.toTronBase58)(fee.address),
+        });
+    }
+    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) => {
+    const isTron = sellAsset.chainId === caip_1.tronChainId;
+    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) && !isTron)
+        return '';
+    if (!(0, utils_1.contractAddressOrUndefined)(sellAsset.assetId))
+        return '';
+    const txTo = (() => {
+        if ('offramp' in quote)
+            return quote.offramp.txTo;
+        if ('tokenSwap' in quote)
+            return quote.tokenSwap.txTo;
+        return '';
+    })();
+    if (!txTo)
+        return '';
+    if (isTron)
+        return (0, exports.toTronBase58)(txTo);
+    return txTo;
+};
+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;