@shapeshiftoss/swapper 17.7.2 → 17.8.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/SunioSwapper/utils/helpers/helpers.d.ts

@@ -1,5 +1,4 @@
 import type { AssetId } from '@shapeshiftoss/caip';
-import { tronChainId } from '@shapeshiftoss/caip';
 export declare const isSupportedChainId: (chainId: string) => boolean;
 export declare const assetIdToTronToken: (assetId: AssetId) => string;
-export declare const isTronChainId: (chainId: string) => chainId is typeof tronChainId;
+export declare const isTronChainId: (chainId: string) => chainId is import("@shapeshiftoss/caip").ChainId;

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

@@ -1,6 +1,6 @@
 export declare const sunioServiceFactory: () => {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
 };
 export type SunioService = ReturnType<typeof sunioServiceFactory>;

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.js

@@ -76,6 +76,11 @@ const expectedQuoteResponse = [
                 thorchainSpecific: {
                     maxStreamingQuantity: undefined,
                 },
+                thorchainTransactionMetadata: {
+                    to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                    data: '0x',
+                    value: '0',
+                },
             },
         ],
     },
@@ -119,6 +124,11 @@ const expectedQuoteResponse = [
                 thorchainSpecific: {
                     maxStreamingQuantity: undefined,
                 },
+                thorchainTransactionMetadata: {
+                    to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                    data: '0x',
+                    value: '0',
+                },
             },
         ],
     },

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailQuote.js

@@ -101,7 +101,7 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps,
+            })),
             isLongtail: true,
             longtailData: {
                 L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailRate.js

@@ -89,7 +89,7 @@ export const getL1ToLongtailRate = async (input, deps, streamingInterval, swappe
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop rate steps here since we're mapping over quote steps,
+            })),
             isLongtail: true,
             longtailData: {
                 L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailQuote.js

@@ -55,7 +55,7 @@ export const getLongtailToL1Quote = async (input, deps, streamingInterval, swapp
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 sellAsset,
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps
+            })),
             isLongtail: true,
             longtailData: {
                 longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailRate.js

@@ -55,7 +55,7 @@ export const getLongtailToL1Rate = async (input, deps, streamingInterval, swappe
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 sellAsset,
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps
+            })),
             isLongtail: true,
             longtailData: {
                 longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ZrxSwapper/utils/fetchFromZrx.js

@@ -24,9 +24,9 @@ const fetchFromZrx = async ({ quoteOrRate, buyAsset, sellAsset, sellAmountInclud
             sellAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             taker: sellAddress,
             swapFeeBps: bn(affiliateBps).toNumber(),
-            swapFeeToken: assetIdToZrxToken(buyAsset.assetId), // must be set to the buy asset to simplify fee calcs
+            swapFeeToken: assetIdToZrxToken(buyAsset.assetId),
             slippageBps: convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toNumber(),
-            swapFeeRecipient: maybeTreasuryAddress, // Where affiliate fees are sent
+            swapFeeRecipient: maybeTreasuryAddress,
             feeRecipientTradeSurplus: maybeTreasuryAddress, // Where trade surplus is sent
         },
     });

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

@@ -1,9 +1,10 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
-import type { ZrxFees, ZrxSupportedChainId } from '../../types.js';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { ZrxFees } from '../../types.js';
 export declare const assetIdToZrxToken: (assetId: AssetId) => string;
 export declare const zrxTokenToAssetId: (token: string, chainId: ChainId) => AssetId;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is ZrxSupportedChainId;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;

package/dist/esm/swappers/ZrxSwapper/utils/zrxService.d.ts

@@ -4,6 +4,6 @@ import type { MonadicSwapperAxiosService } from '../../../types.js';
 type AxiosInstanceHoF = (instance: AxiosInstance, options?: Omit<RetryConfig, 'instance'>) => AxiosInstance;
 export declare const zrxServiceFactory: ({ baseUrl, wrapper, }: {
     baseUrl: string;
-    wrapper?: AxiosInstanceHoF;
+    wrapper?: AxiosInstanceHoF | undefined;
 }) => MonadicSwapperAxiosService;
 export {};

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/swappers/utils/test-data/cryptoMarketDataById.d.ts

@@ -1,39 +1,5 @@
-import { AVAX, BSC, BTC, ETH, FOX_GNOSIS, FOX_MAINNET, OPTIMISM, RUNE, USDC_GNOSIS, USDC_MAINNET, WBTC, WETH } from './assets.js';
 export declare const marketDataByAssetIdUsd: {
-    [FOX_MAINNET.assetId]: {
-        price: string;
-    };
-    [FOX_GNOSIS.assetId]: {
-        price: string;
-    };
-    [ETH.assetId]: {
-        price: string;
-    };
-    [AVAX.assetId]: {
-        price: string;
-    };
-    [BSC.assetId]: {
-        price: string;
-    };
-    [BTC.assetId]: {
-        price: string;
-    };
-    [RUNE.assetId]: {
-        price: string;
-    };
-    [OPTIMISM.assetId]: {
-        price: string;
-    };
-    [USDC_MAINNET.assetId]: {
-        price: string;
-    };
-    [USDC_GNOSIS.assetId]: {
-        price: string;
-    };
-    [WBTC.assetId]: {
-        price: string;
-    };
-    [WETH.assetId]: {
+    [x: string]: {
         price: string;
     };
 };

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

@@ -62,7 +62,14 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
         return { buyTxHash, status: TxStatus.Pending, message };
     }
     catch (e) {
-        console.error(e);
+        const message = (() => {
+            if (axios.isAxiosError(e))
+                return e.response?.data?.message ?? e.message;
+            if (e instanceof Error)
+                return e.message;
+            return String(e);
+        })();
+        console.error(`checkTradeStatus(${nativeChain}, ${txHash}): ${message}`);
         return { buyTxHash: undefined, status: TxStatus.Unknown, message: undefined };
     }
 };

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../../types.js';
+type GetThorTxDataArgs = {
+    sellAsset: Asset;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+};
+type GetThorTxDataReturn = {
+    vault: string;
+};
+export declare const getThorTxData: ({ sellAsset, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+export {};

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.js

@@ -0,0 +1,15 @@
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getChainIdBySwapper, getDaemonUrl } from '../index.js';
+export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
+    // Native assets on the swapper's own chain (RUNE on THORChain, CACAO on MAYAChain)
+    // deposit via MsgDeposit and have no recipient address.
+    if (sellAsset.chainId === getChainIdBySwapper(swapperName))
+        return { vault: '' };
+    // Everything else (e.g. ATOM via THORChain, RUNE via MAYAChain) sends via MsgSend
+    // to the swapper's inbound vault on that chain.
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, true, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    return { vault: res.unwrap().address };
+};

package/dist/esm/thorchain-utils/cosmossdk/index.d.ts

@@ -1 +1,2 @@
 export * from './getCosmosSdkTransactionFees.js';
+export * from './getThorTxData.js';

package/dist/esm/thorchain-utils/cosmossdk/index.js

@@ -1 +1,2 @@
 export * from './getCosmosSdkTransactionFees.js';
+export * from './getThorTxData.js';

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

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { SwapperConfig, SwapperName } from '../types.js';
 import type { ThorEvmTradeQuote } from './types.js';
-export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "vault" | "aggregator" | "data" | "memo" | "tradeType" | "expiry" | "longtailData" | "slippageTolerancePercentageDecimal"> & {
+export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "expiry" | "tradeType" | "aggregator" | "vault" | "longtailData"> & {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     config: SwapperConfig;
     sellAsset: Asset;

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

@@ -7,8 +7,10 @@ import { TronWeb } from 'tronweb';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
 import { buildAffiliateFee } from '../swappers/utils/affiliateFee.js';
+import { isNativeEvmAsset } from '../swappers/utils/helpers/helpers.js';
 import { TradeQuoteError } from '../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../utils.js';
+import * as cosmossdk from './cosmossdk/index.js';
 import * as evm from './evm/index.js';
 import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
 import { getQuote } from './getQuote.js';
@@ -102,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,
             };
@@ -128,12 +130,12 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             affilate: getAffiliate(swapperName),
         });
     };
-    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, }) => {
+    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, thorchainTransactionMetadata, }) => {
         const buyAmountAfterFeesCryptoBaseUnit = convertPrecision({
             value: route.expectedAmountOutThorBaseUnit,
             inputExponent: buyAssetNativePrecision,
             outputExponent: buyAsset.precision,
-        }).toFixed();
+        }).toFixed(0);
         const rate = getInputOutputRate({
             sellAmountCryptoBaseUnit,
             buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -182,6 +184,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     thorchainSpecific: {
                         maxStreamingQuantity: route.quote.max_streaming_quantity,
                     },
+                    thorchainTransactionMetadata,
                 },
             ],
         };
@@ -213,6 +216,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     data,
                     router,
                     vault,
+                    thorchainTransactionMetadata: {
+                        to: router,
+                        data,
+                        value: isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+                    },
                     feeData: {
                         protocolFees: getProtocolFees(route.quote),
                         networkFeeCryptoBaseUnit,
@@ -258,8 +266,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 })();
                 return makeThorTradeRateOrQuote({
                     route,
-                    allowanceContract: '0x0', // not applicable to UTXOs
+                    allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData,
                 });
             }));
@@ -275,11 +288,18 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         case CHAIN_NAMESPACE.CosmosSdk: {
             const cosmosChainAdapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
             const { fast } = await cosmosChainAdapter.getFeeData({});
+            const { vault } = await cosmossdk.getThorTxData({ sellAsset, config, swapperName });
             return Ok(perRouteValues.map((route) => {
+                const memo = getMemo(route);
                 return makeThorTradeRateOrQuote({
                     route,
-                    memo: getMemo(route),
-                    allowanceContract: '0x0', // not applicable to cosmossdk
+                    memo,
+                    allowanceContract: '0x0',
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData: {
                         networkFeeCryptoBaseUnit: fast.txFee,
                         protocolFees: getProtocolFees(route.quote),
@@ -293,13 +313,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         case CHAIN_NAMESPACE.Solana: {
             const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
             const sendAddress = input.sendAddress;
+            const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
                 const protocolFees = getProtocolFees(route.quote);
                 const feeData = await (async () => {
                     if (!sendAddress)
                         return { networkFeeCryptoBaseUnit: undefined, protocolFees };
-                    const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
                     const memoInstruction = new TransactionInstruction({
                         keys: [],
                         programId: new PublicKey(SOLANA_MEMO_PROGRAM_ID),
@@ -325,6 +345,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     route,
                     allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData,
                 });
             }));
@@ -338,23 +363,21 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             return Ok(routes);
         }
         case CHAIN_NAMESPACE.Tron: {
+            const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
                 let networkFeeCryptoBaseUnit = undefined;
                 // Calculate fees for rates when we have a receive address (wallet connected)
-                if (input.quoteOrRate === 'rate' && input.receiveAddress) {
+                if (input.quoteOrRate === 'rate' && input.receiveAddress && vault) {
                     try {
                         const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
                         const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                        // Get vault address
-                        const { vault } = await tron.getThorTxData({
-                            sellAsset,
-                            config,
-                            swapperName,
-                        });
                         // 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;
@@ -364,7 +387,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                             // TRC20: Estimate energy with actual recipient
                             try {
                                 const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
-                                    { type: 'address', value: vault }, // Use vault as recipient
+                                    { type: 'address', value: vault },
                                     {
                                         type: 'uint256',
                                         value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
@@ -398,8 +421,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 // For quotes, fees will be calculated in getTronTransactionFees when executing
                 return Promise.resolve(makeThorTradeRateOrQuote({
                     route,
-                    allowanceContract: '0x0', // not applicable to TRON
+                    allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData: {
                         networkFeeCryptoBaseUnit,
                         protocolFees: getProtocolFees(route.quote),