@shapeshiftoss/swapper 20.2.0 → 20.4.0

package/dist/esm/constants.js

@@ -9,12 +9,14 @@ import { cetusApi, cetusSwapper } from './swappers/CetusSwapper/index.js';
 import { chainflipApi, chainflipSwapper } from './swappers/ChainflipSwapper/index.js';
 import { cowApi, cowSwapper } from './swappers/CowSwapper/index.js';
 import { debridgeApi, debridgeSwapper } from './swappers/DebridgeSwapper/index.js';
+import { fyndApi, fyndSwapper } from './swappers/FyndSwapper/index.js';
 import { mayachainApi, mayachainSwapper } from './swappers/MayachainSwapper/index.js';
 import { nearIntentsApi, nearIntentsSwapper } from './swappers/NearIntentsSwapper/index.js';
 import { portalsApi, portalsSwapper } from './swappers/PortalsSwapper/index.js';
 import { relayApi, relaySwapper } from './swappers/RelaySwapper/index.js';
 import { stonfiApi, stonfiSwapper } from './swappers/StonfiSwapper/index.js';
 import { sunioApi, sunioSwapper } from './swappers/SunioSwapper/index.js';
+import { symbiosisApi, symbiosisSwapper } from './swappers/SymbiosisSwapper/index.js';
 import { thorchainApi, thorchainSwapper } from './swappers/ThorchainSwapper/index.js';
 import { zrxApi, zrxSwapper } from './swappers/ZrxSwapper/index.js';
 import { SwapperName, TradeQuoteError } from './types.js';
@@ -99,6 +101,14 @@ export const swappers = {
         ...bobGatewaySwapper,
         ...bobGatewayApi,
     },
+    [SwapperName.Symbiosis]: {
+        ...symbiosisSwapper,
+        ...symbiosisApi,
+    },
+    [SwapperName.Fynd]: {
+        ...fyndSwapper,
+        ...fyndApi,
+    },
     [SwapperName.Test]: undefined,
 };
 const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002';
@@ -118,12 +128,15 @@ const DEFAULT_STONFI_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
 // deBridge API off-chain simulation overestimates output on some chains (e.g. SEI ~2.4%), so auto slippage (1%) is insufficient
 const DEFAULT_DEBRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0.03';
 const DEFAULT_BOB_GATEWAY_SLIPPAGE_DECIMAL_PERCENTAGE = '0.03';
+// Symbiosis splits the tolerance across up to three legs, and a destination leg over its share pays out the transit token instead of reverting
+const DEFAULT_SYMBIOSIS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
 export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
     if (swapperName === undefined)
         return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
     switch (swapperName) {
         case SwapperName.Zrx:
         case SwapperName.Bebop:
+        case SwapperName.Fynd:
         case SwapperName.Test:
             return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.CowSwap:
@@ -158,6 +171,8 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             return DEFAULT_STONFI_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.BobGateway:
             return DEFAULT_BOB_GATEWAY_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Symbiosis:
+            return DEFAULT_SYMBIOSIS_SLIPPAGE_DECIMAL_PERCENTAGE;
         default:
             return assertUnreachable(swapperName);
     }

package/dist/esm/index.d.ts

@@ -15,11 +15,13 @@ export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/DebridgeSwapper/index.js';
+export * from './swappers/FyndSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';
 export * from './swappers/ButterSwap/index.js';
 export * from './swappers/RelaySwapper/index.js';
+export * from './swappers/SymbiosisSwapper/index.js';
 export * from './utils/helpers.js';
 export * from './utils/thorchain/index.js';
 export * from './types.js';

package/dist/esm/index.js

@@ -15,11 +15,13 @@ export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/DebridgeSwapper/index.js';
+export * from './swappers/FyndSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';
 export * from './swappers/ButterSwap/index.js';
 export * from './swappers/RelaySwapper/index.js';
+export * from './swappers/SymbiosisSwapper/index.js';
 export * from './utils/helpers.js';
 export * from './utils/thorchain/index.js';
 export * from './types.js';

package/dist/esm/swappers/ArbitrumBridgeSwapper/getTradeQuote/getTradeQuote.js

@@ -1,7 +1,6 @@
 import { supportsETH } from '@shapeshiftoss/hdwallet-core';
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getArbitrumBridgeStepData } from '../utils/getArbitrumBridgeStepData.js';
 import { getArbitrumBridgeTradeContext } from '../utils/getArbitrumBridgeTradeContext.js';
 export const getTradeQuoteWithWallet = async (inputWithWallet, deps) => {
@@ -33,7 +32,6 @@ export const getTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
         receiveAddress,
         steps: [
             {

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

@@ -2,7 +2,6 @@ import { Err, Ok } from '@sniptt/monads';
 import { validateAndParseAddress } from 'starknet';
 import { TradeQuoteError } from '../../../types.js';
 import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getAvnuTradeContext } from '../utils/getAvnuTradeContext.js';
 export const getTradeQuote = async (input, deps) => {
     const { sellAsset, accountNumber } = input;
@@ -33,7 +32,7 @@ export const getTradeQuote = async (input, deps) => {
             ...tradeCommon,
             receiveAddress: normalizedReceiveAddress,
             quoteOrRate: 'quote',
-            deadline: deadline ?? Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+            deadline,
             steps: [
                 {
                     ...stepCommon,

package/dist/esm/swappers/BebopSwapper/utils/fetchFromBebop.d.ts

@@ -13,12 +13,13 @@ export declare const fetchBebopQuote: ({ buyAsset, sellAsset, sellAmountIncludin
     affiliateBps?: string | undefined;
     apiKey: string;
 }) => Promise<Result<BebopQuoteResponse, SwapErrorRight>>;
-export declare const fetchBebopSolanaQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, apiKey, }: {
+export declare const fetchBebopSolanaQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }: {
     buyAsset: Asset;
     sellAsset: Asset;
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     takerAddress: string;
     receiverAddress: string;
     slippageTolerancePercentageDecimal: string;
+    affiliateBps?: string | undefined;
     apiKey: string;
 }) => Promise<Result<BebopSolanaQuoteResponse, SwapErrorRight>>;

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

@@ -8,6 +8,9 @@ import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
 import { chainIdToBebopChain } from '../types.js';
 import { bebopServiceFactory } from './bebopService.js';
 import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers.js';
+// PMM charges the fee set against our api key, which nets exactly this bps
+const BEBOP_PMM_AFFILIATE_BPS = '60';
+const isPmmEligible = (affiliateBps) => bnOrZero(affiliateBps).eq(BEBOP_PMM_AFFILIATE_BPS);
 export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
         const sellToken = assetIdToBebopToken(sellAsset.assetId);
@@ -27,26 +30,24 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
             approval_type: 'Standard',
             skip_validation: 'true',
             gasless: 'false',
-            // PMM fees are configured against our api key on Bebop's side, not sent per quote
             source: 'shapeshift',
         };
         const jamParams = new URLSearchParams(baseParams);
-        const pmmParams = new URLSearchParams(baseParams);
-        // JAM settles the fee on-chain, so it still takes our bps and a recipient per quote
-        if (affiliateBps && affiliateBps !== '0') {
-            jamParams.set('fee', affiliateBps);
-            jamParams.set('fee_recipient', getAddress(getTreasuryAddressFromChainId(buyAsset.chainId)));
-        }
+        // Without an explicit fee JAM charges our api key's flat fee, so 1 bps is the lowest it can go
+        jamParams.set('fee', affiliateBps && bnOrZero(affiliateBps).gt(0) ? affiliateBps : '1');
+        jamParams.set('fee_recipient', getAddress(getTreasuryAddressFromChainId(buyAsset.chainId)));
         const service = bebopServiceFactory({ apiKey });
-        const [maybeJam, maybePmm] = await Promise.all([
+        const requests = [
             service.get(`https://api.bebop.xyz/jam/${chainName}/v2/quote`, {
                 params: jamParams,
             }),
-            service.get(`https://api.bebop.xyz/pmm/${chainName}/v3/quote`, {
-                params: pmmParams,
-            }),
-        ]);
-        const maybeResponses = [maybeJam, maybePmm];
+        ];
+        if (isPmmEligible(affiliateBps)) {
+            requests.push(service.get(`https://api.bebop.xyz/pmm/${chainName}/v3/quote`, {
+                params: new URLSearchParams(baseParams),
+            }));
+        }
+        const maybeResponses = await Promise.all(requests);
         if (maybeResponses.every(maybeResponse => maybeResponse.isErr())) {
             return Err(makeSwapErrorRight({
                 message: 'Failed to fetch quote from Bebop',
@@ -76,8 +77,14 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
         }));
     }
 };
-export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, apiKey, }) => {
+export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
+        if (!isPmmEligible(affiliateBps)) {
+            return Err(makeSwapErrorRight({
+                message: 'Bebop Solana is PMM only and cannot take the requested bps',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
         // Bebop's Solana routes don't wrap native SOL on the input side, so selling native SOL
         // always fails on-chain. Reject up front instead of returning an unexecutable quote.
         if (sellAsset.assetId === solAssetId) {
@@ -100,7 +107,6 @@ export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountInc
             approval_type: 'Standard',
             skip_validation: 'false',
             gasless: 'true',
-            // Solana is PMM only, so its fees are configured against our api key on Bebop's side
             source: 'shapeshift',
         });
         const maybeResponse = await bebopServiceFactory({ apiKey }).get('https://api.bebop.xyz/pmm/solana/v3/quote', { params });

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

@@ -19,6 +19,7 @@ export const getBebopSolanaTradeContext = async ({ input, deps, takerAddress, re
         takerAddress,
         receiverAddress,
         slippageTolerancePercentageDecimal,
+        affiliateBps,
         apiKey: deps.config.VITE_BEBOP_API_KEY,
     });
     if (maybeBebopQuoteResponse.isErr())

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

@@ -1,6 +1,15 @@
-import { executeEvmTransaction, executeTronTransaction } from '../../utils/index.js';
+import { executeEvmTransaction, executeTronTransaction, getSwapMetadata } from '../../utils/index.js';
+import { submitBobGatewayBtcDeposit } from './utils/helpers.js';
 export const bobGatewaySwapper = {
     executeEvmTransaction,
-    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => signAndBroadcastTransaction(txToSign),
+    executeUtxoTransaction: async (txToSign, { signTransaction }, context) => {
+        if (!signTransaction)
+            throw new Error('[BobGateway] signTransaction is required');
+        if (!context)
+            throw new Error('[BobGateway] execution context is required');
+        const { orderId } = getSwapMetadata(context.swapperMetadata, 'bob');
+        const bitcoinTxHex = await signTransaction(txToSign);
+        return submitBobGatewayBtcDeposit({ config: context.config, orderId, bitcoinTxHex });
+    },
     executeTronTransaction,
 };

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

@@ -1,13 +1,12 @@
 import { isGatewayError } from '@gobob/bob-sdk';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote } from '../../utils/index.js';
+import { getSwapMetadata } from '../../utils/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
-import { getTronTransactionFees } from '../../utils/tron/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } 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();
+import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus } from './utils/helpers.js';
 export const bobGatewayApi = {
     getTradeRate: (input, deps) => getBobGatewayTradeRate(input, deps),
     getTradeQuote: (input, deps) => getBobGatewayTradeQuote(input, deps),
@@ -15,42 +14,12 @@ export const bobGatewayApi = {
     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,
-        });
-    },
+    getUnsignedTronTransaction,
     getTronTransactionFees,
-    checkTradeStatus: async ({ swap, config, txHash }) => {
+    checkTradeStatus: async ({ swap, config }) => {
         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);

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

@@ -1,7 +1,6 @@
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { btcChainId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getBobGatewayStepData } from '../utils/getBobGatewayStepData.js';
 import { getBobGatewayTradeContext } from '../utils/getBobGatewayTradeContext.js';
 export const getBobGatewayTradeQuote = async (input, deps) => {
@@ -10,18 +9,15 @@ export const getBobGatewayTradeQuote = async (input, deps) => {
     if (maybeAddresses.isErr())
         return Err(maybeAddresses.unwrapErr());
     const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
-    const isEvmSell = isEvmChainId(sellAsset.chainId);
-    // 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 = isEvmSell ? sendAddress : undefined;
-    // utxo deposits are refunded on the sell chain, so refunds go to the sending address
-    const refundAddress = isEvmSell ? undefined : sendAddress;
+    const isBtcSell = sellAsset.chainId === btcChainId;
+    // omit the sender for btc sells so the sdk doesn't build a psbt from a single address
+    const sender = isBtcSell ? undefined : sendAddress;
     const maybeContext = await getBobGatewayTradeContext({
         input,
         deps,
         sender,
         recipient: receiveAddress,
-        refundAddress,
+        refundAddress: sendAddress,
     });
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());
@@ -38,7 +34,6 @@ export const getBobGatewayTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
         receiveAddress,
         steps: [
             {

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

@@ -8,8 +8,7 @@ export const getBobGatewayTradeRate = async (input, deps) => {
     const isBtcSell = sellAsset.chainId === btcChainId;
     const recipient = receiveAddress ?? dummyAddressForChainId(buyAsset.chainId);
     const sender = isBtcSell ? undefined : dummyAddressForChainId(sellAsset.chainId);
-    // utxo deposits are refunded on the sell chain, so the refund address must be a btc address
-    const refundAddress = isBtcSell ? dummyAddressForChainId(sellAsset.chainId) : undefined;
+    const refundAddress = dummyAddressForChainId(sellAsset.chainId);
     const maybeContext = await getBobGatewayTradeContext({
         input,
         deps,

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

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

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

@@ -1,13 +1,14 @@
 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";
+    readonly [x: string]: "ethereum" | "polygon" | "arbitrum" | "base" | "avalanche" | "bsc" | "robinhood" | "bob" | "plasma" | "tron" | "bera" | "bitcoin" | "sei" | "sonic" | "unichain" | "hyperevm";
 };
 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 BOB_GATEWAY_TRON_DEFAULT_ENERGY = "420000";
+export declare const BOB_GATEWAY_TRON_DEFAULT_BANDWIDTH_BYTES = 4000;
 export declare const decimalSlippageToBobBps: (slippageDecimal: string) => string;

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

@@ -1,9 +1,7 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, btcChainId, ethChainId, hyperEvmChainId, plasmaChainId, polygonChainId, seiChainId, sonicChainId, 
-// tronChainId,
-unichainChainId, } from '@shapeshiftoss/caip';
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, btcChainId, ethChainId, hyperEvmChainId, plasmaChainId, polygonChainId, robinhoodChainId, 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
+// https://gateway-api-mainnet.gobob.xyz/v4/get-routes
 export const chainIdToBobGatewayChainName = {
     [arbitrumChainId]: 'arbitrum',
     [avalancheChainId]: 'avalanche',
@@ -18,15 +16,18 @@ export const chainIdToBobGatewayChainName = {
     [unichainChainId]: 'unichain',
     [plasmaChainId]: 'plasma',
     [polygonChainId]: 'polygon',
-    [hyperEvmChainId]: 'hyperliquid',
-    // [tronChainId]: 'tron',
+    [hyperEvmChainId]: 'hyperevm',
+    [robinhoodChainId]: 'robinhood',
+    [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
+// AllowanceHolder exec measured on mainnet: rates price it before an order exists, token quotes without their allowance fall back to it
+export const BOB_GATEWAY_TRON_DEFAULT_ENERGY = '420000';
+export const BOB_GATEWAY_TRON_DEFAULT_BANDWIDTH_BYTES = 4000;
 // 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

@@ -1,8 +1,8 @@
-import type { GatewayQuoteV3 } from '@gobob/bob-sdk';
+import type { GatewayQuoteV4 } from '@gobob/bob-sdk';
 import type { Result } from '@sniptt/monads';
 import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
 type BaseArgs = {
-    quote: GatewayQuoteV3;
+    quote: GatewayQuoteV4;
     sellAmountCryptoBaseUnit: string;
     spenderAddress: string;
 };

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

@@ -1,12 +1,12 @@
 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 { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/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';
+import { BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT, BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT, BOB_GATEWAY_TRON_DEFAULT_BANDWIDTH_BYTES, BOB_GATEWAY_TRON_DEFAULT_ENERGY, } from './constants.js';
+import { createBobGatewayOrder } from './helpers.js';
 export async function getBobGatewayStepData(args) {
     const { input, quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, deps } = args;
     const { chainNamespace } = fromChainId(sellAsset.chainId);
@@ -139,19 +139,17 @@ export async function getBobGatewayStepData(args) {
         // 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') {
+                // The gateway call isn't built until an order exists, so rates price a measured default
                 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 await getTronContractCallFallbackFeeCryptoBaseUnit({
+                            adapter,
+                            energy: BOB_GATEWAY_TRON_DEFAULT_ENERGY,
+                            bandwidthBytes: BOB_GATEWAY_TRON_DEFAULT_BANDWIDTH_BYTES,
+                            contractAddress: spenderAddress,
+                            fullEnergyOnShareLookupFailure: true,
                         });
-                        return fast.txFee;
                     }
                     catch { }
                 })();
@@ -165,22 +163,20 @@ export async function getBobGatewayStepData(args) {
             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,
-            };
+            const call = { 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,
+                    transactionData: { type: 'tron', ...call },
+                    networkFeeCryptoBaseUnit: await getTronContractCallNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        transactionData: call,
+                        from,
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                        fallbackEnergy: BOB_GATEWAY_TRON_DEFAULT_ENERGY,
+                    }),
                 };
                 return Ok(stepData);
             }

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,115 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { Ok } from '@sniptt/monads';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../../../utils/test-data/assets.js';
+import { getBobGatewayStepData } from './getBobGatewayStepData.js';
+import { createBobGatewayOrder } from './helpers.js';
+vi.mock('./helpers', () => ({ createBobGatewayOrder: vi.fn() }));
+const USDT_TRON = {
+    ...ETH,
+    assetId: `${tronChainId}/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t`,
+    chainId: tronChainId,
+};
+const FROM = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';
+// BOB returns the AllowanceHolder as 0x-prefixed 41-hex (TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K)
+const ALLOWANCE_HOLDER_HEX = '0x4107a39ae4c49dee86e892450b20881f32cd5d500d';
+const tronTx = { type: 'tron', to: ALLOWANCE_HOLDER_HEX, data: '0x2213bc0b', value: '0' };
+const tronAdapter = ({ txFee = '45600000', allowance = '0' } = {}) => ({
+    getFeeData: vi.fn().mockResolvedValue({ fast: { txFee } }),
+    httpProvider: {
+        getChainPrices: () => Promise.resolve({ energyPrice: 100, bandwidthPrice: 1000 }),
+        getTrc20Allowance: vi.fn().mockResolvedValue(allowance),
+        getTrc20Balance: vi.fn().mockResolvedValue('100000000'),
+        getContractEnergyShare: vi.fn().mockResolvedValue({
+            callerPercent: 100,
+            originEnergyLimit: 0,
+            originEnergyAvailable: 0,
+        }),
+    },
+});
+const makeDeps = (tron) => ({ config: {}, assertGetTronChainAdapter: () => tron });
+const quote = {};
+describe('getBobGatewayStepData', () => {
+    describe('tron', () => {
+        it('prices a rate from the measured default energy and bandwidth at the gateway share', async () => {
+            const adapter = tronAdapter();
+            const actual = await getBobGatewayStepData({
+                type: 'rate',
+                input: {},
+                deps: makeDeps(adapter),
+                quote,
+                sellAsset: USDT_TRON,
+                sellAmountCryptoBaseUnit: '100000000',
+                spenderAddress: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+            });
+            // 420000 energy * 1.2 margin * 100 sun + 4000 bytes * 1000 sun
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '54400000' });
+            expect(adapter.httpProvider.getContractEnergyShare).toHaveBeenCalledWith('TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K');
+        });
+        it('simulates the real gateway call for a quote', async () => {
+            vi.mocked(createBobGatewayOrder).mockResolvedValue(Ok({ offramp: { orderId: 'order-1', tx: tronTx } }));
+            const adapter = tronAdapter();
+            const actual = await getBobGatewayStepData({
+                type: 'quote',
+                input: {},
+                deps: makeDeps(adapter),
+                quote,
+                sellAsset: USDT_TRON,
+                sellAmountCryptoBaseUnit: '100000000',
+                spenderAddress: '',
+                from: FROM,
+            });
+            expect(adapter.getFeeData).toHaveBeenCalledWith({
+                to: ALLOWANCE_HOLDER_HEX,
+                value: '0',
+                chainSpecific: { from: FROM, data: '0x2213bc0b', requireEnergyShare: true },
+            });
+            expect(actual.unwrap()).toEqual({
+                orderId: 'order-1',
+                transactionData: { type: 'tron', to: ALLOWANCE_HOLDER_HEX, data: '0x2213bc0b', value: '0' },
+                networkFeeCryptoBaseUnit: '45600000',
+            });
+        });
+        it('prices the measured worst case when the allowance is not granted yet', async () => {
+            vi.mocked(createBobGatewayOrder).mockResolvedValue(Ok({ offramp: { orderId: 'order-1', tx: tronTx } }));
+            const adapter = tronAdapter({ allowance: '0' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getBobGatewayStepData({
+                type: 'quote',
+                input: {},
+                deps: makeDeps(adapter),
+                quote,
+                sellAsset: USDT_TRON,
+                sellAmountCryptoBaseUnit: '100000000',
+                spenderAddress: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+                from: FROM,
+            });
+            // 420000 energy * 1.2 margin * 100 sun + (4 calldata + 279 envelope) bytes * 1000 sun
+            expect(actual.unwrap()).toMatchObject({
+                orderId: 'order-1',
+                networkFeeCryptoBaseUnit: '50683000',
+            });
+            expect(adapter.httpProvider.getTrc20Allowance).toHaveBeenCalledWith({
+                contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+                owner: FROM,
+                spender: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+            });
+        });
+        it('fails the quote when the simulation reverts with the allowance in place', async () => {
+            vi.mocked(createBobGatewayOrder).mockResolvedValue(Ok({ offramp: { orderId: 'order-1', tx: tronTx } }));
+            const adapter = tronAdapter({ allowance: '100000000' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getBobGatewayStepData({
+                type: 'quote',
+                input: {},
+                deps: makeDeps(adapter),
+                quote,
+                sellAsset: USDT_TRON,
+                sellAmountCryptoBaseUnit: '100000000',
+                spenderAddress: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+                from: FROM,
+            });
+            expect(actual.isErr()).toBe(true);
+        });
+    });
+});

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

@@ -1,4 +1,3 @@
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { SwapperName } from '../../../types.js';
@@ -58,7 +57,7 @@ export const getBobGatewayTradeContext = async ({ input, deps, sender, recipient
             quote,
             sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             sellAsset,
-            spenderAddress: isEvmChainId(sellAsset.chainId) ? allowanceContract : '',
+            spenderAddress: allowanceContract,
             deps,
         },
     });