@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/esm/swappers/BebopSwapper/utils/{helpers/helpers.js → helpers.js}

@@ -3,12 +3,9 @@ import { bn, convertPrecision, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { getAddress } from 'viem';
-import { TradeQuoteError } from '../../../../types.js';
-import { makeSwapErrorRight } from '../../../../utils.js';
-import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../../types.js';
-export const isSolanaChainId = (chainId) => {
-    return chainId === solanaChainId;
-};
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../types.js';
 export const assetIdToBebopToken = (assetId) => {
     if (!isToken(assetId))
         return BEBOP_NATIVE_MARKER;

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

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

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

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

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

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

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

@@ -0,0 +1,81 @@
+import { isGatewayError } from '@gobob/bob-sdk';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getTronTransactionFees } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
+import { getBobGatewayTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getBobGatewayTradeRate } from './swapperApi/getTradeRate.js';
+import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus, registerBobGatewayTx, toTronBase58, } from './utils/helpers.js';
+const registeredSwapIds = new Set();
+export const bobGatewayApi = {
+    getTradeRate: (input, deps) => getBobGatewayTradeRate(input, deps),
+    getTradeQuote: (input, deps) => getBobGatewayTradeQuote(input, deps),
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    getUnsignedTronTransaction: ({ from, stepIndex, tradeQuote, assertGetTronChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('[BobGateway] unable to execute a trade rate');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, transactionData } = step;
+        if (transactionData?.type !== 'tron')
+            throw new Error('[BobGateway] invalid tron transaction');
+        const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+        const { to, data, value } = transactionData;
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            from,
+            to: toTronBase58(to),
+            value,
+            data,
+        });
+    },
+    getTronTransactionFees,
+    checkTradeStatus: async ({ swap, config, txHash }) => {
+        if (!swap)
+            throw new Error('[BobGateway] swap is required for status check');
+        const { orderId } = getSwapMetadata(swap.metadata.swapperMetadata, 'bob');
+        if (txHash && !registeredSwapIds.has(swap.id)) {
+            try {
+                await registerBobGatewayTx({
+                    config,
+                    orderId,
+                    txHash,
+                    sellAsset: swap.sellAsset,
+                    buyAsset: swap.buyAsset,
+                });
+                registeredSwapIds.add(swap.id);
+            }
+            catch { }
+        }
+        let orderInfo;
+        try {
+            orderInfo = await getBobGatewayClient(config).getOrder(orderId);
+        }
+        catch (err) {
+            if (isGatewayError(err)) {
+                if (err.code === 'ORDER_NOT_FOUND') {
+                    return {
+                        buyTxHash: undefined,
+                        status: TxStatus.Unknown,
+                        message: 'Waiting for deposit...',
+                    };
+                }
+            }
+            throw err;
+        }
+        const status = mapBobGatewayOrderStatusToTxStatus(orderInfo.status);
+        const buyTxHash = 'success' in orderInfo.status ? orderInfo.status.success.receivedTokens[0]?.txHash : undefined;
+        const refundTxHash = 'refunded' in orderInfo.status
+            ? orderInfo.status.refunded.refundedTokens[0]?.txHash
+            : undefined;
+        return {
+            status,
+            buyTxHash,
+            message: refundTxHash ? 'Trade refunded' : undefined,
+        };
+    },
+};

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getBobGatewayStepData } from '../utils/getBobGatewayStepData.js';
+import { getBobGatewayTradeContext } from '../utils/getBobGatewayTradeContext.js';
+export const getBobGatewayTradeQuote = async (input, deps) => {
+    const { sellAsset, accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    // omit the sender for utxo sells so order creation does not enforce a per-address confirmed
+    // funds check (deposits are matched via op_return, not the sending address)
+    const sender = isEvmChainId(sellAsset.chainId) ? sendAddress : undefined;
+    const maybeContext = await getBobGatewayTradeContext({
+        input,
+        deps,
+        sender,
+        recipient: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getBobGatewayStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { orderId, transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                swapperMetadata: { name: 'bob', orderId },
+                transactionData,
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

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

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

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

@@ -0,0 +1,31 @@
+import { btcChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { getBobGatewayStepData } from '../utils/getBobGatewayStepData.js';
+import { getBobGatewayTradeContext } from '../utils/getBobGatewayTradeContext.js';
+import { dummyAddressForChainId } from '../utils/helpers.js';
+export const getBobGatewayTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, receiveAddress } = input;
+    const recipient = receiveAddress ?? dummyAddressForChainId(buyAsset.chainId);
+    const sender = sellAsset.chainId === btcChainId ? undefined : dummyAddressForChainId(sellAsset.chainId);
+    const maybeContext = await getBobGatewayTradeContext({ input, deps, sender, recipient });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getBobGatewayStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
+};

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

@@ -0,0 +1,7 @@
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput } from '../../types.js';
+export type BobGatewayMetadata = {
+    name: 'bob';
+    orderId: string;
+};
+export type BobGatewayTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput;
+export type BobGatewayTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput;

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

@@ -0,0 +1,13 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const BOB_GATEWAY_BASE_URL = "https://gateway-api-mainnet.gobob.xyz";
+export declare const chainIdToBobGatewayChainName: {
+    readonly [x: string]: "ethereum" | "polygon" | "arbitrum" | "base" | "avalanche" | "bsc" | "bob" | "plasma" | "bera" | "bitcoin" | "sei" | "sonic" | "unichain" | "hyperliquid";
+};
+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 DUMMY_TRON_ADDRESS = "TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N";
+export declare const BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = "350000";
+export declare const BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = "550000";
+export declare const decimalSlippageToBobBps: (slippageDecimal: string) => string;

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

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

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

@@ -0,0 +1,24 @@
+import type { GatewayQuoteV3 } from '@gobob/bob-sdk';
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+type BaseArgs = {
+    quote: GatewayQuoteV3;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+};
+export type GetBobGatewayStepDataArgs = StepDataArgs<BaseArgs>;
+type BobGatewayRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type BobGatewayQuoteStepData = {
+    orderId: string;
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+export declare function getBobGatewayStepData(args: Extract<GetBobGatewayStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<BobGatewayRateStepData, SwapErrorRight>>;
+export declare function getBobGatewayStepData(args: Extract<GetBobGatewayStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<BobGatewayQuoteStepData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,197 @@
+import { CHAIN_NAMESPACE, fromChainId } from '@shapeshiftoss/caip';
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getUtxoNetworkFeeCryptoBaseUnit, UTXO_PLACEHOLDER_ADDRESS } from '../../../utils/utxo/index.js';
+import { BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT, BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT, } from './constants.js';
+import { createBobGatewayOrder, toTronBase58 } from './helpers.js';
+export async function getBobGatewayStepData(args) {
+    const { input, quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, deps } = args;
+    const { chainNamespace } = 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 Ok({ type: 'rate' });
+        const maybeOrderResponse = await createBobGatewayOrder(deps.config, quote);
+        if (maybeOrderResponse.isErr())
+            return Err(maybeOrderResponse.unwrapErr());
+        return Ok({
+            type: 'quote',
+            orderResponse: maybeOrderResponse.unwrap(),
+            from: args.from,
+        });
+    })();
+    if (maybeResolved.isErr())
+        return Err(maybeResolved.unwrapErr());
+    const resolved = maybeResolved.unwrap();
+    switch (chainNamespace) {
+        // BTC sells (onramp BTC -> EVM/TRON)
+        case 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 getUtxoNetworkFeeCryptoBaseUnit({
+                            adapter,
+                            pubkey,
+                            to: input.sendAddress ?? UTXO_PLACEHOLDER_ADDRESS,
+                            value: sellAmountCryptoBaseUnit,
+                        });
+                        return networkFeeCryptoBaseUnit;
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            const { orderResponse } = resolved;
+            if (!('onramp' in orderResponse))
+                return Err(makeTradeStepBuildFailedErr('getBobGatewayStepData'));
+            const transactionData = {
+                type: 'utxo',
+                to: orderResponse.onramp.address,
+                opReturnData: orderResponse.onramp.opReturnData ?? undefined,
+                value: sellAmountCryptoBaseUnit,
+            };
+            try {
+                const { networkFeeCryptoBaseUnit } = await getUtxoNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    pubkey,
+                    to: transactionData.to,
+                    value: sellAmountCryptoBaseUnit,
+                    opReturnData: transactionData.opReturnData,
+                });
+                const stepData = {
+                    orderId: orderResponse.onramp.orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit,
+                };
+                return Ok(stepData);
+            }
+            catch (err) {
+                return Err(makeNetworkFeeEstimationFailedErr('getBobGatewayStepData', err));
+            }
+        }
+        // EVM sells (offramp EVM → BTC, or tokenSwap EVM → Tron)
+        case 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
+                            ? BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT
+                            : BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT;
+                        return await getEvmNetworkFeeCryptoBaseUnit({
+                            adapter,
+                            supportsEIP1559: 'supportsEIP1559' in input ? input.supportsEIP1559 : false,
+                            gasLimit,
+                        });
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            const { orderResponse, from } = resolved;
+            if (!('offramp' in orderResponse) && !('tokenSwap' in orderResponse))
+                return Err(makeTradeStepBuildFailedErr('getBobGatewayStepData'));
+            const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+            if (order.tx.type !== 'evm')
+                return Err(makeTradeStepBuildFailedErr('getBobGatewayStepData'));
+            const { tx, orderId } = order;
+            if (!('supportsEIP1559' in input))
+                return Err(makeTradeStepBuildFailedErr('getBobGatewayStepData'));
+            const transactionData = {
+                type: 'evm',
+                chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+            };
+            try {
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559: input.supportsEIP1559,
+                    stateOverride: {
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                    },
+                });
+                const stepData = {
+                    orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit,
+                };
+                return Ok(stepData);
+            }
+            catch (err) {
+                return Err(makeNetworkFeeEstimationFailedErr('getBobGatewayStepData', err));
+            }
+        }
+        // Tron sells (offramp Tron → BTC, or tokenSwap TRON → EVM)
+        case CHAIN_NAMESPACE.Tron: {
+            const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+            const contractAddress = 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: toTronBase58(order.txTo),
+                            value: order.inputAmount.amount,
+                            chainSpecific: { contractAddress },
+                        });
+                        return fast.txFee;
+                    }
+                    catch { }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            const { orderResponse, from } = resolved;
+            if (!('offramp' in orderResponse) && !('tokenSwap' in orderResponse))
+                return Err(makeTradeStepBuildFailedErr('getBobGatewayStepData'));
+            const order = 'offramp' in orderResponse ? orderResponse.offramp : orderResponse.tokenSwap;
+            if (order.tx.type !== 'tron')
+                return Err(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: toTronBase58(tx.to),
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from, contractAddress },
+                });
+                const stepData = {
+                    orderId,
+                    transactionData,
+                    networkFeeCryptoBaseUnit: fast.txFee,
+                };
+                return Ok(stepData);
+            }
+            catch (err) {
+                return Err(makeNetworkFeeEstimationFailedErr('getBobGatewayStepData', err));
+            }
+        }
+        default:
+            return Err(makeSwapErrorRight({
+                message: `[BobGateway] unsupported chain namespace: ${chainNamespace}`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+    }
+}

package/dist/esm/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.js';
+import type { BobGatewayTradeQuoteInput, BobGatewayTradeRateInput } from '../types.js';
+import type { GetBobGatewayStepDataArgs } from './getBobGatewayStepData.js';
+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/esm/swappers/BobGatewaySwapper/utils/getBobGatewayTradeContext.js

@@ -0,0 +1,64 @@
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName } from '../../../types.js';
+import { getInputOutputRate } from '../../../utils/index.js';
+import { assertValidTrade, getBobGatewayAllowanceContract, getBobGatewayQuote, parseBobGatewayQuote, } from './helpers.js';
+export const getBobGatewayTradeContext = async ({ input, deps, sender, recipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    const maybeQuote = await getBobGatewayQuote({
+        config: deps.config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = parseBobGatewayQuote(quote, buyAsset, deps.assetsById);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = getBobGatewayAllowanceContract(quote, sellAsset);
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.BobGateway,
+        },
+        stepCommon: {
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            rate,
+            source: SwapperName.BobGateway,
+            buyAsset,
+            sellAsset,
+            allowanceContract,
+            estimatedExecutionTimeMs,
+        },
+        protocolFees,
+        stepDataArgs: {
+            quote,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            spenderAddress: isEvmChainId(sellAsset.chainId) ? allowanceContract : '',
+            deps,
+        },
+    });
+};

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