@shapeshiftoss/swapper 20.2.0 → 20.3.0

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/swapperApi/getTradeQuote.js

@@ -56,7 +56,7 @@ export const getTradeQuote = async (input, deps) => {
     });
     if (maybeStepData.isErr())
         return Err(maybeStepData.unwrapErr());
-    const { networkFeeCryptoBaseUnit, transactionData, butterSwapTransactionMetadata } = maybeStepData.unwrap();
+    const { networkFeeCryptoBaseUnit, transactionData } = maybeStepData.unwrap();
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
@@ -66,10 +66,9 @@ export const getTradeQuote = async (input, deps) => {
             {
                 ...stepCommon,
                 accountNumber,
-                // Tron exec still builds from legacy metadata whose spender is the buildTx target
+                // Tron routes pull the sell token from the buildTx target
                 allowanceContract: sellAsset.chainId === tronChainId ? buildTx.to : stepCommon.allowanceContract,
                 transactionData,
-                butterSwapTransactionMetadata,
                 feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
         ],

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

@@ -2,17 +2,6 @@ import type { Hex } from 'viem';
 import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput } from '../../types.js';
 export type ButterSwapTradeQuoteInput = GetEvmTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput;
 export type ButterSwapTradeRateInput = GetEvmTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
-export type ButterSwapTransactionMetadata = {
-    to: string;
-    data: string;
-    value: Hex;
-    method?: string;
-    args?: {
-        type: string;
-        value: unknown;
-    }[];
-    memo?: string;
-};
 export type ErrorType = {
     errno: number;
     message: string;

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

@@ -1 +1,3 @@
+export declare const BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY = "1000000";
+export declare const BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES = 2400;
 export declare const makeButterSwapAffiliate: (affiliateBps: string) => string | undefined;

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

@@ -1,5 +1,8 @@
 import { bnOrZero } from '@shapeshiftoss/utils';
 const BUTTERSWAP_AFFILIATE = 'shapeshift';
+// The router's total energy per swap, before its deployer's share comes off
+export const BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY = '1000000';
+export const BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES = 2400;
 // Format is `<nickname>[:rate]`, where rate is in basis points (e.g. `shapeshift:60` = 0.6%).
 export const makeButterSwapAffiliate = (affiliateBps) => {
     if (bnOrZero(affiliateBps).lte(0))

package/dist/esm/swappers/ButterSwap/utils/getButterSwapStepData.d.ts

@@ -2,7 +2,7 @@ import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
 import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
-import type { BuildTxSuccessItem, ButterSwapTransactionMetadata, RouteSuccessItem } from '../types.js';
+import type { BuildTxSuccessItem, RouteSuccessItem } from '../types.js';
 export declare const BUTTERSWAP_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
 type BaseArgs = {
     route: RouteSuccessItem;
@@ -19,8 +19,7 @@ type ButterSwapRateStepData = {
     networkFeeCryptoBaseUnit: string;
 };
 type ButterSwapQuoteStepData = {
-    transactionData?: TxBuildData;
-    butterSwapTransactionMetadata?: ButterSwapTransactionMetadata;
+    transactionData: TxBuildData;
     networkFeeCryptoBaseUnit: string;
 };
 export declare function getButterSwapStepData(args: Extract<GetButterSwapStepDataArgs, {