@shapeshiftoss/swapper 20.1.1 → 20.3.0

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

@@ -13,13 +13,12 @@ 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, affiliateBps, apiKey, }: {
+export declare const fetchBebopSolanaQuote: ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, 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

@@ -27,16 +27,15 @@ 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') {
-            // JAM collects the fee on-chain and requires a recipient
             jamParams.set('fee', affiliateBps);
             jamParams.set('fee_recipient', getAddress(getTreasuryAddressFromChainId(buyAsset.chainId)));
-            // PMM attributes the fee off-chain via source
-            pmmParams.set('fee', affiliateBps);
         }
         const service = bebopServiceFactory({ apiKey });
         const [maybeJam, maybePmm] = await Promise.all([
@@ -77,7 +76,7 @@ export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncluding
         }));
     }
 };
-export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
+export const fetchBebopSolanaQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, apiKey, }) => {
     try {
         // 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.
@@ -101,11 +100,9 @@ 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',
         });
-        if (affiliateBps && affiliateBps !== '0') {
-            params.set('fee', affiliateBps);
-        }
         const maybeResponse = await bebopServiceFactory({ apiKey }).get('https://api.bebop.xyz/pmm/solana/v3/quote', { params });
         if (maybeResponse.isErr()) {
             const err = maybeResponse.unwrapErr();

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

@@ -19,7 +19,6 @@ 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,4 +1,4 @@
-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';
@@ -10,18 +10,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());

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,
         },
     });

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

@@ -1,4 +1,4 @@
-import type { GatewayOrderStatusV3, GatewayQuoteV3, GetQuoteParams } from '@gobob/bob-sdk';
+import type { GatewayOrderStatusV3, GatewayQuoteV4, 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';
@@ -8,7 +8,6 @@ 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, refundAddress, amount, affiliateBps, slippageTolerancePercentageDecimal, }: {
@@ -23,23 +22,21 @@ export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellCha
     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, }: {
+}) => Promise<Result<GatewayQuoteV4, SwapErrorRight>>;
+export declare const createBobGatewayOrder: (config: SwapperConfig, quote: GatewayQuoteV4) => 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 submitBobGatewayBtcDeposit: ({ config, orderId, bitcoinTxHex, }: {
     config: SwapperConfig;
     orderId: string;
-    txHash: string;
-    sellAsset: Asset;
-    buyAsset: Asset;
-}) => Promise<void>;
+    bitcoinTxHex: string;
+}) => Promise<string>;
 export declare const mapBobGatewayOrderStatusToTxStatus: (status: GatewayOrderStatusV3) => TxStatus;
-export declare const parseBobGatewayQuote: (quote: GatewayQuoteV3, buyAsset: Asset, assetsById: AssetsByIdPartial) => {
+export declare const parseBobGatewayQuote: (quote: GatewayQuoteV4, 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 getBobGatewayAllowanceContract: (quote: GatewayQuoteV4, sellAsset: Asset) => string;
 export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
     sellAsset: Asset;
     buyAsset: Asset;

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

@@ -1,33 +1,27 @@
 import { GatewayErrorCode, GatewaySDK, isGatewayError } from '@gobob/bob-sdk';
+import * as bitcoin from '@shapeshiftoss/bitcoinjs-lib';
 import { ASSET_NAMESPACE, btcChainId, ethChainId, fromAssetId, toAssetId, tronChainId, } from '@shapeshiftoss/caip';
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { isEvmChainId, tron } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { bnOrZero, chainIdToFeeAssetId, contractAddressOrUndefined, isToken, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { TronWeb } from 'tronweb';
 import { getAddress, zeroAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../../utils/index.js';
 import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
-import { BOB_GATEWAY_BASE_URL, bobGatewayChainNameToChainId, chainIdToBobGatewayChainName, decimalSlippageToBobBps, DUMMY_BTC_ADDRESS, DUMMY_EVM_ADDRESS, DUMMY_TRON_ADDRESS, } from './constants.js';
+import { TRON_PLACEHOLDER_ADDRESS } from '../../../utils/tron/index.js';
+import { BOB_GATEWAY_BASE_URL, bobGatewayChainNameToChainId, chainIdToBobGatewayChainName, decimalSlippageToBobBps, DUMMY_BTC_ADDRESS, DUMMY_EVM_ADDRESS, } from './constants.js';
 export const dummyAddressForChainId = (chainId) => {
     if (chainId === btcChainId)
         return DUMMY_BTC_ADDRESS;
     if (chainId === tronChainId)
-        return DUMMY_TRON_ADDRESS;
+        return TRON_PLACEHOLDER_ADDRESS;
     return DUMMY_EVM_ADDRESS;
 };
 export const getBobGatewayClient = (config) => {
     return new GatewaySDK({ basePath: BOB_GATEWAY_BASE_URL, apiKey: config.VITE_BOB_GATEWAY_API_KEY });
 };
-export const toTronBase58 = (address) => {
-    if (address.startsWith('T'))
-        return address;
-    if (address.startsWith('0x'))
-        return TronWeb.address.fromHex(address.slice(2));
-    return TronWeb.address.fromHex(address);
-};
 export const assetIdToBobGatewayToken = (assetId) => {
     // BOB Gateway uses the zero address as the token address for native assets
     if (!isToken(assetId))
@@ -54,7 +48,6 @@ export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChai
             toUserAddress: recipient,
             amount,
             maxSlippage: Number(slippage),
-            ownerAddress: sellChainName === 'bitcoin' ? recipient : sender,
             refundAddress,
             affiliates: getBobGatewayAffiliates(affiliateBps),
         });
@@ -99,7 +92,7 @@ export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChai
 };
 export const createBobGatewayOrder = async (config, quote) => {
     try {
-        const order = await getBobGatewayClient(config).api.createOrderV3({ gatewayQuoteV3: quote });
+        const order = await getBobGatewayClient(config).api.createOrderV4({ gatewayQuoteV4: quote });
         return Ok(order);
     }
     catch (err) {
@@ -117,21 +110,11 @@ export const createBobGatewayOrder = async (config, quote) => {
         }));
     }
 };
-export const registerBobGatewayTx = async ({ config, orderId, txHash, sellAsset, buyAsset, }) => {
-    const registerTxV3 = (() => {
-        const sellChainName = chainIdToBobGatewayChainName[sellAsset.chainId];
-        // BTC→EVM
-        if (sellChainName === 'bitcoin') {
-            return { onramp: { orderId, bitcoinTxid: txHash } };
-        }
-        // EVM→BTC
-        if (chainIdToBobGatewayChainName[buyAsset.chainId] === 'bitcoin') {
-            return { offramp: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
-        }
-        // EVM→EVM
-        return { tokenSwap: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
-    })();
-    await getBobGatewayClient(config).api.registerTxV3({ registerTxV3 });
+export const submitBobGatewayBtcDeposit = async ({ config, orderId, bitcoinTxHex, }) => {
+    await getBobGatewayClient(config).api.registerTxV4({
+        registerTxV4: { onramp: { orderId, bitcoinTxHex } },
+    });
+    return bitcoin.Transaction.fromHex(bitcoinTxHex).getId();
 };
 export const mapBobGatewayOrderStatusToTxStatus = (status) => {
     if ('inProgress' in status)
@@ -154,7 +137,7 @@ const bobGatewayFeeToAssetId = (fee) => {
         return toAssetId({
             chainId,
             assetNamespace: ASSET_NAMESPACE.trc20,
-            assetReference: toTronBase58(fee.address),
+            assetReference: tron.toTronBase58(fee.address),
         });
     }
     return toAssetId({
@@ -227,7 +210,7 @@ export const getBobGatewayAllowanceContract = (quote, sellAsset) => {
     if (!txTo)
         return '';
     if (isTron)
-        return toTronBase58(txTo);
+        return tron.toTronBase58(txTo);
     return txTo;
 };
 export const assertValidTrade = ({ sellAsset, buyAsset, }) => {

package/dist/esm/swappers/ButterSwap/ButterSwap.js

@@ -3,7 +3,4 @@ export const butterSwap = {
     executeEvmTransaction,
     executeSolanaTransaction,
     executeTronTransaction,
-    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
-        return signAndBroadcastTransaction(txToSign);
-    },
 };