@shapeshiftoss/swapper 17.7.3 → 17.8.0

package/dist/esm/swappers/SunioSwapper/utils/buildSwapRouteParameters.js

@@ -2,12 +2,12 @@ import { bn } from '@shapeshiftoss/utils';
 export const buildSwapRouteParameters = (route, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, recipient, slippageTolerancePercentageDecimal) => {
     const path = route.tokens;
     const poolVersion = route.poolVersions;
-    const versionLen = poolVersion.map((_, index) => {
-        if (index === poolVersion.length - 1) {
-            return path.length - index;
-        }
-        return 2;
-    });
+    // The SmartExchangeRouter expects sum(versionLen) === path.length: the first
+    // pool segment consumes 2 tokens (input + output) and each subsequent pool
+    // reuses the previous output, consuming 1 new token. This relies on the Sun.io
+    // API returning poolVersions per-hop (poolVersions.length === tokens.length - 1),
+    // which it does — the router also accepts this un-collapsed form for same-version hops.
+    const versionLen = poolVersion.map((_, index) => (index === 0 ? 2 : 1));
     const fees = route.poolFees.map(fee => Number(fee));
     const amountOutWithSlippage = bn(minBuyAmountCryptoBaseUnit)
         .times(bn(1).minus(slippageTolerancePercentageDecimal))

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

@@ -2,5 +2,7 @@ export declare const SUNIO_SUPPORTED_CHAIN_IDS: readonly [import("@shapeshiftoss
 export declare const SUNIO_API_BASE_URL = "https://rot.endjgfsv.link";
 export declare const SUNIO_SMART_ROUTER_CONTRACT: "TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj";
 export declare const DEFAULT_SLIPPAGE_PERCENTAGE = "0.005";
+export declare const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = 215000;
+export declare const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = 375000;
 export declare const SUNIO_DEX_TYPES: "PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3";
 export declare const SUNIO_TRON_NATIVE_ADDRESS: "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";

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

@@ -8,6 +8,12 @@ export const SUNIO_API_BASE_URL = 'https://rot.endjgfsv.link';
 // This is the current mainnet router that sun.io's frontend uses
 export const SUNIO_SMART_ROUTER_CONTRACT = 'TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj';
 export const DEFAULT_SLIPPAGE_PERCENTAGE = '0.005';
+// Energy fallbacks for when we can't simulate a swap (no address, or the simulation reverts
+// pre-approval for TRC20 sells). Set to observed average energy so the 1.2x margin applied at
+// estimate time lifts them to cover the worst case (native ~245k, TRC20 ~415k due to the extra
+// transferFrom token pull) without double-counting safety.
+export const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = 215_000;
+export const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = 375_000;
 export const SUNIO_DEX_TYPES = 'PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3';
 // Native TRX token address (used when assetId is not a TRC-20 token)
 export const SUNIO_TRON_NATIVE_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';

package/dist/esm/swappers/SunioSwapper/utils/estimateSunioNetworkFee.d.ts

@@ -0,0 +1,12 @@
+import type { SunioRoute } from '../types.js';
+type EstimateSunioNetworkFeeArgs = {
+    rpcUrl: string;
+    apiKey: string;
+    route: SunioRoute;
+    sellAmountCryptoBaseUnit: string;
+    isSellingNativeTrx: boolean;
+    address: string | undefined;
+    slippageTolerancePercentageDecimal: string | undefined;
+};
+export declare const estimateSunioNetworkFeeCryptoBaseUnit: ({ rpcUrl, apiKey, route, sellAmountCryptoBaseUnit, isSellingNativeTrx, address, slippageTolerancePercentageDecimal, }: EstimateSunioNetworkFeeArgs) => Promise<string>;
+export {};

package/dist/esm/swappers/SunioSwapper/utils/estimateSunioNetworkFee.js

@@ -0,0 +1,74 @@
+import { bn } from '@shapeshiftoss/utils';
+import { TronWeb } from 'tronweb';
+import { buildSwapExactInputParameters, SUNIO_SWAP_EXACT_INPUT_SELECTOR, } from './buildSwapContractCall.js';
+import { buildSwapRouteParameters } from './buildSwapRouteParameters.js';
+import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_FALLBACK_SWAP_ENERGY_NATIVE, SUNIO_FALLBACK_SWAP_ENERGY_TRC20, SUNIO_SMART_ROUTER_CONTRACT, SUNIO_TRON_NATIVE_ADDRESS, } from './constants.js';
+// Estimates the network fee (in TRX base units) for a Sun.io swap. The router sponsors only ~1%
+// of energy (origin_energy_usage); the user pays the rest, so we simulate the real swapExactInput
+// call when we have an address to estimate from. The simulation reverts before approval for TRC20
+// sells (and when the account lacks the sell balance), so we fall back to a conservative per-sell-
+// type constant. Used both at quote time and re-run at confirm time, where a now-granted allowance
+// lets the simulation produce the true cost.
+export const estimateSunioNetworkFeeCryptoBaseUnit = async ({ rpcUrl, apiKey, route, sellAmountCryptoBaseUnit, isSellingNativeTrx, address, slippageTolerancePercentageDecimal, }) => {
+    const tronGridHeaders = apiKey ? { 'TRON-PRO-API-KEY': apiKey } : {};
+    const tronWeb = new TronWeb({ fullHost: rpcUrl, headers: tronGridHeaders });
+    // Live network prices, defaulting if the node is unavailable so we still produce a fee
+    const { bandwidthPrice, energyPrice } = await (async () => {
+        try {
+            const params = await tronWeb.trx.getChainParameters();
+            return {
+                bandwidthPrice: params.find(p => p.key === 'getTransactionFee')?.value ?? 1000,
+                energyPrice: params.find(p => p.key === 'getEnergyFee')?.value ?? 100,
+            };
+        }
+        catch {
+            return { bandwidthPrice: 1000, energyPrice: 100 };
+        }
+    })();
+    // Account activation (1 TRX) is only charged when the recipient receives native TRX, mirroring
+    // the chain adapter. A TRC20 buy doesn't incur the flat activation fee (its account-creation
+    // cost is folded into energy). Only checkable with an address.
+    const isBuyingNativeTrx = route.tokens[route.tokens.length - 1] === SUNIO_TRON_NATIVE_ADDRESS;
+    const accountActivationFee = await (async () => {
+        if (!address || !isBuyingNativeTrx)
+            return 0;
+        try {
+            const recipientInfoResponse = await fetch(`${rpcUrl}/wallet/getaccount`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...tronGridHeaders },
+                body: JSON.stringify({ address, visible: true }),
+            });
+            const recipientInfo = await recipientInfoResponse.json();
+            const recipientExists = recipientInfo && Object.keys(recipientInfo).length > 1;
+            return recipientExists ? 0 : 1_000_000; // 1 TRX
+        }
+        catch {
+            return 0;
+        }
+    })();
+    const energyUsed = await (async () => {
+        // TRC20 sells cost far more energy than native sells (the extra transferFrom token pull)
+        const fallbackEnergy = isSellingNativeTrx
+            ? SUNIO_FALLBACK_SWAP_ENERGY_NATIVE
+            : SUNIO_FALLBACK_SWAP_ENERGY_TRC20;
+        if (!address)
+            return fallbackEnergy;
+        try {
+            const routeParams = buildSwapRouteParameters(route, sellAmountCryptoBaseUnit, '0', address, slippageTolerancePercentageDecimal ?? DEFAULT_SLIPPAGE_PERCENTAGE);
+            const callValue = isSellingNativeTrx ? Number(sellAmountCryptoBaseUnit) : 0;
+            const result = await tronWeb.transactionBuilder.triggerConstantContract(SUNIO_SMART_ROUTER_CONTRACT, SUNIO_SWAP_EXACT_INPUT_SELECTOR, { callValue }, buildSwapExactInputParameters(routeParams), address);
+            // A reverted simulation (e.g. TRC20 sell pre-approval) can still return a small energy_used;
+            // only trust it when the call actually succeeded, otherwise use the conservative fallback.
+            if (result?.result?.result !== true || result.energy_used == null)
+                return fallbackEnergy;
+            return result.energy_used;
+        }
+        catch {
+            return fallbackEnergy;
+        }
+    })();
+    // 1.2x safety margin for energy price/usage variance between estimate and execution
+    const energyFee = Math.ceil(energyUsed * energyPrice * 1.2);
+    const bandwidthFee = 1100 * bandwidthPrice;
+    return bn(energyFee).plus(bandwidthFee).plus(accountActivationFee).toFixed(0);
+};

package/dist/esm/swappers/SunioSwapper/utils/getQuoteOrRate.js

@@ -1,11 +1,11 @@
 import { tronChainId } from '@shapeshiftoss/caip';
 import { BigAmount, bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { TronWeb } from 'tronweb';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
 import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
+import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
 import { fetchSunioQuote } from './fetchFromSunio.js';
 import { isSupportedChainId } from './helpers/helpers.js';
 import { sunioServiceFactory } from './sunioService.js';
@@ -57,83 +57,25 @@ export async function getQuoteOrRate(input, deps) {
                 code: TradeQuoteError.InternalError,
             }));
         }
-        // Fetch network fees for both quotes and rates (when wallet connected)
-        let networkFeeCryptoBaseUnit = undefined;
-        // Estimate fees when we have an address to estimate from
-        if (receiveAddress) {
+        const networkFeeCryptoBaseUnit = await (async () => {
             try {
-                const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                const isSellingNativeTrx = !contractAddress;
-                const tronWeb = new TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
-                // Get chain parameters for pricing
-                const params = await tronWeb.trx.getChainParameters();
-                const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
-                const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 100;
-                // Check if recipient needs activation (applies to all swaps)
-                let accountActivationFee = 0;
-                try {
-                    const recipientInfoResponse = await fetch(`${deps.config.VITE_TRON_NODE_URL}/wallet/getaccount`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ address: receiveAddress, visible: true }),
-                    });
-                    const recipientInfo = await recipientInfoResponse.json();
-                    const recipientExists = recipientInfo && Object.keys(recipientInfo).length > 1;
-                    if (!recipientExists) {
-                        accountActivationFee = 1_000_000; // 1 TRX
-                    }
-                }
-                catch {
-                    // Ignore activation check errors
-                }
-                // For native TRX swaps, Sun.io uses a contract call with value
-                // We need to estimate energy for the swap contract, not just bandwidth
-                if (isSellingNativeTrx) {
-                    try {
-                        // Sun.io contract owner provides most energy (~117k), users only pay ~2k
-                        // Use fixed 2k energy estimate instead of querying (which returns total 120k)
-                        const energyUsed = 2000; // User pays ~2k energy, contract covers the rest
-                        const energyFee = energyUsed * energyPrice; // No multiplier - contract provides energy
-                        // Estimate bandwidth for contract call (much larger than simple transfer)
-                        const bandwidthFee = 1100 * bandwidthPrice; // ~1100 bytes for contract call (with safety buffer)
-                        networkFeeCryptoBaseUnit = bn(energyFee)
-                            .plus(bandwidthFee)
-                            .plus(accountActivationFee)
-                            .toFixed(0);
-                    }
-                    catch (estimationError) {
-                        // Fallback estimate: ~2k energy + ~1100 bytes bandwidth + activation fee
-                        const fallbackEnergyFee = 2000 * energyPrice;
-                        const fallbackBandwidthFee = 1100 * bandwidthPrice;
-                        networkFeeCryptoBaseUnit = bn(fallbackEnergyFee)
-                            .plus(fallbackBandwidthFee)
-                            .plus(accountActivationFee)
-                            .toFixed(0);
-                    }
-                }
-                else {
-                    // For TRC-20 swaps through Sun.io router
-                    // Same as TRX: contract owner provides most energy, user pays ~2k
-                    // Sun.io provides ~217k energy, user pays ~2k
-                    const energyFee = 2000 * energyPrice;
-                    const bandwidthFee = 1100 * bandwidthPrice;
-                    networkFeeCryptoBaseUnit = bn(energyFee)
-                        .plus(bandwidthFee)
-                        .plus(accountActivationFee)
-                        .toFixed(0);
-                }
+                return await estimateSunioNetworkFeeCryptoBaseUnit({
+                    rpcUrl: deps.config.VITE_TRON_NODE_URL,
+                    apiKey: deps.config.VITE_TRON_GRID_API_KEY,
+                    route: bestRoute,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    isSellingNativeTrx: !contractAddressOrUndefined(sellAsset.assetId),
+                    address: receiveAddress,
+                    slippageTolerancePercentageDecimal,
+                });
             }
             catch (error) {
-                // For rates, fall back to '0' on estimation failure
-                // For quotes, let it error (required for accurate swap)
-                if (!isQuote) {
-                    networkFeeCryptoBaseUnit = '0';
-                }
-                else {
-                    throw error;
-                }
+                // For rates, fall back to '0' on unexpected failure; quotes require an accurate fee
+                if (!isQuote)
+                    return '0';
+                throw error;
             }
-        }
+        })();
         const buyAmountCryptoBaseUnit = BigAmount.fromPrecision({
             value: bestRoute.amountOut,
             precision: buyAsset.precision,

package/dist/esm/swappers/SunioSwapper/utils/getSunioTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs } from '../../../types.js';
+export declare const getSunioTransactionFees: ({ tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, }: GetUnsignedTronTransactionArgs) => Promise<string>;

package/dist/esm/swappers/SunioSwapper/utils/getSunioTransactionFees.js

@@ -0,0 +1,32 @@
+import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../../utils.js';
+import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
+export const getSunioTransactionFees = async ({ tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const storedNetworkFeeCryptoBaseUnit = step.feeData.networkFeeCryptoBaseUnit;
+    const route = step.sunioTransactionMetadata?.route;
+    if (!route) {
+        if (!storedNetworkFeeCryptoBaseUnit)
+            throw new Error('Missing network fee in quote');
+        return storedNetworkFeeCryptoBaseUnit;
+    }
+    try {
+        const adapter = assertGetTronChainAdapter(tronChainId);
+        return await estimateSunioNetworkFeeCryptoBaseUnit({
+            rpcUrl: adapter.httpProvider.getRpcUrl(),
+            apiKey: config.VITE_TRON_GRID_API_KEY,
+            route,
+            sellAmountCryptoBaseUnit: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            isSellingNativeTrx: step.sellAsset.assetId === tronAssetId,
+            address: from,
+            slippageTolerancePercentageDecimal,
+        });
+    }
+    catch {
+        if (!storedNetworkFeeCryptoBaseUnit)
+            throw new Error('Missing network fee in quote');
+        return storedNetworkFeeCryptoBaseUnit;
+    }
+};

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

@@ -1,6 +1,6 @@
 import { arbitrumAssetId, avalancheAssetId, baseAssetId, bscAssetId, ethAssetId, fromAssetId, gnosisAssetId, katanaAssetId, monadAssetId, optimismAssetId, plasmaAssetId, polygonAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
-import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_HYPEREVM, DAO_TREASURY_MONAD, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, DAO_TREASURY_TON, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BOB, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_HYPEREVM, DAO_TREASURY_MONAD, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, DAO_TREASURY_TON, isTreasuryChainId, } from '@shapeshiftoss/utils';
 export const isNativeEvmAsset = (assetId) => {
     const { chainId } = fromAssetId(assetId);
     switch (chainId) {
@@ -45,6 +45,7 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [KnownChainIds.TonMainnet]: DAO_TREASURY_TON,
     [KnownChainIds.MonadMainnet]: DAO_TREASURY_MONAD,
     [KnownChainIds.HyperEvmMainnet]: DAO_TREASURY_HYPEREVM,
+    [KnownChainIds.BobMainnet]: DAO_TREASURY_BOB,
 };
 export const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = isTreasuryChainId(chainId) ? chainId : undefined;

package/dist/esm/thorchain-utils/getL1RateOrQuote.js

@@ -104,7 +104,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         const protocolFees = {};
         if (!buyAssetTradeFeeBuyAssetCryptoBaseUnit.isZero()) {
             protocolFees[buyAsset.assetId] = {
-                amountCryptoBaseUnit: buyAssetTradeFeeBuyAssetCryptoBaseUnit.toString(),
+                amountCryptoBaseUnit: buyAssetTradeFeeBuyAssetCryptoBaseUnit.toFixed(0),
                 requiresBalance: false,
                 asset: buyAsset,
             };
@@ -135,7 +135,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             value: route.expectedAmountOutThorBaseUnit,
             inputExponent: buyAssetNativePrecision,
             outputExponent: buyAsset.precision,
-        }).toFixed();
+        }).toFixed(0);
         const rate = getInputOutputRate({
             sellAmountCryptoBaseUnit,
             buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -375,6 +375,9 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                         // Estimate fees using the receive address for accurate energy calculation
                         const tronWeb = new TronWeb({
                             fullHost: deps.config.VITE_TRON_NODE_URL,
+                            headers: deps.config.VITE_TRON_GRID_API_KEY
+                                ? { 'TRON-PRO-API-KEY': deps.config.VITE_TRON_GRID_API_KEY }
+                                : {},
                         });
                         const params = await tronWeb.trx.getChainParameters();
                         const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;

package/dist/esm/thorchain-utils/getQuote.js

@@ -4,19 +4,10 @@ import { Err, Ok } from '@sniptt/monads';
 import qs from 'qs';
 import { TradeQuoteError } from '../types.js';
 import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../utils.js';
-import { getThresholdedAffiliateBps } from './getThresholdedAffiliateBps/getThresholdedAffiliateBps.js';
 import { getAffiliate, getDaemonUrl, getNativePrecision, getPoolAssetId } from './index.js';
 import { thorService } from './service.js';
 export const getQuote = async (input, deps) => {
     const { buyAssetId, receiveAddress, sellAsset, sellAmountCryptoBaseUnit, streaming, streamingInterval, affiliateBps, swapperName, } = input;
-    // don't apply an affiliate fee if it's below the outbound fee for the inbound pool
-    const thresholdedAffiliateBps = await getThresholdedAffiliateBps({
-        sellAsset,
-        sellAmountCryptoBaseUnit,
-        affiliateBps,
-        config: deps.config,
-        swapperName,
-    });
     const buyPoolId = getPoolAssetId({ assetId: buyAssetId, swapperName });
     const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
     const sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
@@ -37,33 +28,40 @@ export const getQuote = async (input, deps) => {
         from_asset: sellPoolId,
         to_asset: buyPoolId,
         destination: parsedReceiveAddress,
-        affiliate_bps: thresholdedAffiliateBps,
+        affiliate_bps: affiliateBps,
         affiliate: getAffiliate(swapperName),
         ...(streaming && { streaming_interval: streamingInterval }),
     });
     const daemonUrl = getDaemonUrl(deps.config, swapperName);
     const res = await thorService.get(`${daemonUrl}/quote/swap?${queryString}`);
-    if (res.isErr())
-        return Err(res.unwrapErr());
-    const { data } = res.unwrap();
-    const isError = 'error' in data;
-    const notEnoughFeeError = isError && /not enough fee/i.test(data.error);
-    const notEnoughToPayTxFeeError = isError && /not enough to pay transaction fee/i.test(data.error);
-    const tradingIsHaltedError = isError && /trading is halted/.test(data.error);
-    if (notEnoughFeeError || notEnoughToPayTxFeeError)
-        return Err(createTradeAmountTooSmallErr());
-    if (tradingIsHaltedError) {
-        return Err(makeSwapErrorRight({
-            message: `[getQuote]: Trading is halted, cannot process swap`,
-            code: TradeQuoteError.TradingHalted,
-            details: { sellAssetId: sellAsset.assetId, buyAssetId },
-        }));
-    }
-    if (isError) {
+    // Thornode returns errors as `{ error: string }` in both the 2xx body and the 4xx body.
+    // On 4xx axios rejects, so the body lands on `cause.response.data` instead of in the success data.
+    const errorMessage = (() => {
+        if (res.isErr()) {
+            const cause = res.unwrapErr().cause;
+            return cause?.response?.data?.error;
+        }
+        const { data } = res.unwrap();
+        return 'error' in data ? data.error : undefined;
+    })();
+    if (errorMessage) {
+        if (/not enough fee/i.test(errorMessage) ||
+            /not enough to pay transaction fee/i.test(errorMessage)) {
+            return Err(createTradeAmountTooSmallErr());
+        }
+        if (/trading is halted/i.test(errorMessage)) {
+            return Err(makeSwapErrorRight({
+                message: `[getQuote]: Trading is halted, cannot process swap`,
+                code: TradeQuoteError.TradingHalted,
+                details: { sellAssetId: sellAsset.assetId, buyAssetId },
+            }));
+        }
         return Err(makeSwapErrorRight({
-            message: data.error,
+            message: errorMessage,
             code: TradeQuoteError.UnknownError,
         }));
     }
-    return Ok(data);
+    if (res.isErr())
+        return Err(res.unwrapErr());
+    return Ok(res.unwrap().data);
 };

package/dist/esm/thorchain-utils/tron/getTronTransactionFees.js

@@ -2,9 +2,9 @@ import { bnOrZero, contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { TronWeb } from 'tronweb';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { getThorTxData } from './getThorTxData.js';
-const getChainPrices = async (rpcUrl) => {
+const getChainPrices = async (rpcUrl, headers) => {
     try {
-        const tronWeb = new TronWeb({ fullHost: rpcUrl });
+        const tronWeb = new TronWeb({ fullHost: rpcUrl, headers });
         const params = await tronWeb.trx.getChainParameters();
         const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
         const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 420;
@@ -26,11 +26,14 @@ export const getTronTransactionFees = async (args, swapperName) => {
     const { vault } = await getThorTxData({ sellAsset, config, swapperName });
     const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
     const rpcUrl = config.VITE_TRON_NODE_URL;
+    const tronGridHeaders = config.VITE_TRON_GRID_API_KEY
+        ? { 'TRON-PRO-API-KEY': config.VITE_TRON_GRID_API_KEY }
+        : {};
     try {
-        const tronWeb = new TronWeb({ fullHost: rpcUrl });
+        const tronWeb = new TronWeb({ fullHost: rpcUrl, headers: tronGridHeaders });
         if (contractAddress) {
             // TRC20 transfer - estimate energy cost
-            const { energyPrice } = await getChainPrices(rpcUrl);
+            const { energyPrice } = await getChainPrices(rpcUrl, tronGridHeaders);
             const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
                 { type: 'address', value: vault },
                 { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
@@ -41,7 +44,7 @@ export const getTronTransactionFees = async (args, swapperName) => {
         }
         else {
             // TRX transfer with memo - build transaction to get accurate size
-            const { bandwidthPrice } = await getChainPrices(rpcUrl);
+            const { bandwidthPrice } = await getChainPrices(rpcUrl, tronGridHeaders);
             let tx = await tronWeb.transactionBuilder.sendTrx(vault, bnOrZero(sellAmountIncludingProtocolFeesCryptoBaseUnit).toNumber(), from);
             // Add memo to get accurate size with memo overhead
             const txWithMemo = await tronWeb.transactionBuilder.addUpdateData(tx, memo, 'utf8');

package/dist/esm/thorchain-utils/types.d.ts

@@ -71,7 +71,7 @@ export type ThornodeQuoteResponseSuccess = {
     total_swap_seconds?: number;
     warning: string;
 };
-type ThornodeResponseError = {
+export type ThornodeResponseError = {
     error: string;
 };
 export type ThornodeQuoteResponse = ThornodeQuoteResponseSuccess | ThornodeResponseError;

package/dist/esm/types.d.ts

@@ -11,6 +11,7 @@ import type Polyglot from 'node-polyglot';
 import type { InterpolationOptions } from 'node-polyglot';
 import type { Address, Hex } from 'viem';
 import type { AcrossTransactionMetadata } from './swappers/AcrossSwapper/utils/types.js';
+import type { BobGatewayMetadata } from './swappers/BobGatewaySwapper/types.js';
 import type { CowMessageToSign } from './swappers/CowSwapper/types.js';
 import type { DebridgeTransactionMetadata } from './swappers/DebridgeSwapper/utils/types.js';
 import type { RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types.js';
@@ -22,6 +23,7 @@ export type SwapperConfig = {
     VITE_THORCHAIN_NODE_URL: string;
     VITE_MAYACHAIN_NODE_URL: string;
     VITE_TRON_NODE_URL: string;
+    VITE_TRON_GRID_API_KEY: string;
     VITE_FEATURE_THORCHAINSWAP_LONGTAIL: boolean;
     VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL: boolean;
     VITE_THORCHAIN_MIDGARD_URL: string;
@@ -50,6 +52,7 @@ export type SwapperConfig = {
     VITE_ACROSS_API_URL: string;
     VITE_ACROSS_INTEGRATOR_ID: string;
     VITE_DEBRIDGE_API_URL: string;
+    VITE_BOB_GATEWAY_API_KEY: string;
 };
 export declare enum SwapperName {
     Thorchain = "THORChain",
@@ -69,7 +72,8 @@ export declare enum SwapperName {
     Avnu = "AVNU",
     Stonfi = "STON.fi",
     Across = "Across",
-    Debridge = "deBridge"
+    Debridge = "deBridge",
+    BobGateway = "BOB Gateway"
 }
 export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
 export type SwapErrorRight = {
@@ -95,7 +99,9 @@ export declare enum TradeQuoteError {
     FinalQuoteMaxSlippageExceeded = "FinalQuoteMaxSlippageExceeded",
     FinalQuoteExecutionReverted = "FinalQuoteExecutionReverted",
     Timeout = "Timeout",
-    UnknownError = "UnknownError"
+    UnknownError = "UnknownError",
+    InsufficientFunds = "InsufficientFunds",
+    InsufficientFundsUnconfirmed = "InsufficientFundsUnconfirmed"
 }
 export type UtxoFeeData = {
     satsPerByte: string;
@@ -133,7 +139,6 @@ type CommonTradeInputBase = {
     buyAsset: Asset;
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     affiliateBps: string;
-    affiliateAddress?: string;
     allowMultiHop: boolean;
     slippageTolerancePercentageDecimal?: string;
 };
@@ -402,6 +407,7 @@ export type TradeQuoteStep = {
     };
     acrossTransactionMetadata?: AcrossTransactionMetadata;
     debridgeTransactionMetadata?: DebridgeTransactionMetadata;
+    bobSpecific?: BobGatewayMetadata;
     affiliateFee?: AffiliateFee;
 };
 export type TradeRateStep = Omit<TradeQuoteStep, 'accountNumber'> & {
@@ -458,6 +464,7 @@ export type SwapperSpecificMetadata = {
     relayTransactionMetadata: RelayTransactionMetadata | undefined;
     acrossTransactionMetadata: AcrossTransactionMetadata | undefined;
     debridgeTransactionMetadata: DebridgeTransactionMetadata | undefined;
+    bobSpecific?: BobGatewayMetadata;
     relayerExplorerTxLink: string | undefined;
     relayerTxHash: string | undefined;
     stepIndex: SupportedTradeQuoteStepIndex;

package/dist/esm/types.js

@@ -18,6 +18,7 @@ export var SwapperName;
     SwapperName["Stonfi"] = "STON.fi";
     SwapperName["Across"] = "Across";
     SwapperName["Debridge"] = "deBridge";
+    SwapperName["BobGateway"] = "BOB Gateway";
 })(SwapperName || (SwapperName = {}));
 export var TradeQuoteError;
 (function (TradeQuoteError) {
@@ -53,6 +54,10 @@ export var TradeQuoteError;
     TradeQuoteError["Timeout"] = "Timeout";
     // catch-all for unknown issues
     TradeQuoteError["UnknownError"] = "UnknownError";
+    // the swapper performed on chain balance checks and determined the user didn't have the funds to perform the swap
+    TradeQuoteError["InsufficientFunds"] = "InsufficientFunds";
+    // the user's confirmed balance is insufficient — funds may exist but are still confirming on chain (e.g. unconfirmed UTXO deposits)
+    TradeQuoteError["InsufficientFundsUnconfirmed"] = "InsufficientFundsUnconfirmed";
 })(TradeQuoteError || (TradeQuoteError = {}));
 export var TransactionExecutionState;
 (function (TransactionExecutionState) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "17.7.3",
+  "version": "17.8.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -28,6 +28,7 @@
     "@coral-xyz/anchor": "0.29.0",
     "@cowprotocol/app-data": "^2.3.0",
     "@defuse-protocol/one-click-sdk-typescript": "^0.1.1-0.2",
+    "@gobob/bob-sdk": "5.6.0",
     "@mysten/sui": "^1.45.2",
     "@shapeshiftoss/bitcoinjs-lib": "7.0.0-shapeshift.0",
     "@sniptt/monads": "^0.5.10",
@@ -49,13 +50,13 @@
     "retry-axios": "^2.6.0",
     "uuid": "^9.0.0",
     "viem": "2.43.5",
-    "@shapeshiftoss/caip": "^8.16.7",
-    "@shapeshiftoss/chain-adapters": "^11.3.9",
-    "@shapeshiftoss/contracts": "^1.0.5-coderabbit-fix.2",
-    "@shapeshiftoss/types": "^8.6.7",
+    "@shapeshiftoss/caip": "^8.16.9",
+    "@shapeshiftoss/chain-adapters": "^11.4.0",
+    "@shapeshiftoss/contracts": "^1.0.7",
     "@shapeshiftoss/hdwallet-core": "^1.62.41",
-    "@shapeshiftoss/unchained-client": "^10.14.10",
-    "@shapeshiftoss/utils": "^1.0.5"
+    "@shapeshiftoss/types": "^8.6.8",
+    "@shapeshiftoss/utils": "^1.1.0",
+    "@shapeshiftoss/unchained-client": "^10.14.11"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.178",

package/dist/cjs/swappers/SunioSwapper/utils/buildSwapTransaction.d.ts

@@ -1,11 +0,0 @@
-import type { SunioRoute } from '../types';
-export type BuildSwapTransactionArgs = {
-    route: SunioRoute;
-    from: string;
-    to: string;
-    sellAmountCryptoBaseUnit: string;
-    minBuyAmountCryptoBaseUnit: string;
-    rpcUrl: string;
-    deadline?: number;
-};
-export declare const buildSunioSwapTransaction: (args: BuildSwapTransactionArgs) => Promise<any>;