@shapeshiftoss/swapper 17.6.7 → 17.6.8

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

@@ -0,0 +1,53 @@
+import { TronWeb } from 'tronweb';
+import { SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
+const convertAddressesToEvmFormat = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(v => convertAddressesToEvmFormat(v));
+    }
+    if (typeof value === 'string' && value.startsWith('T') && TronWeb.isAddress(value)) {
+        const hex = TronWeb.address.toHex(value);
+        return hex.replace(/^41/, '0x');
+    }
+    return value;
+};
+export const buildSunioSwapTransaction = async (args) => {
+    const { route, from, to, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, rpcUrl, deadline, } = args;
+    const tronWeb = new TronWeb({
+        fullHost: rpcUrl,
+    });
+    const path = route.tokens;
+    const poolVersion = route.poolVersions;
+    const versionLen = Array(poolVersion.length).fill(2);
+    const fees = route.poolFees.map(fee => Number(fee));
+    const swapData = {
+        amountIn: sellAmountCryptoBaseUnit,
+        amountOutMin: minBuyAmountCryptoBaseUnit,
+        recipient: to,
+        deadline: deadline ?? Math.floor(Date.now() / 1000) + 60 * 20,
+    };
+    const parameters = [
+        { type: 'address[]', value: path },
+        { type: 'string[]', value: poolVersion },
+        { type: 'uint256[]', value: versionLen },
+        { type: 'uint24[]', value: fees },
+        {
+            type: 'tuple(uint256,uint256,address,uint256)',
+            value: convertAddressesToEvmFormat([
+                swapData.amountIn,
+                swapData.amountOutMin,
+                swapData.recipient,
+                swapData.deadline,
+            ]),
+        },
+    ];
+    const functionSelector = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
+    const options = {
+        feeLimit: 100_000_000,
+        callValue: 0,
+    };
+    const txData = await tronWeb.transactionBuilder.triggerSmartContract(SUNIO_SMART_ROUTER_CONTRACT, functionSelector, options, parameters, from);
+    if (!txData.result || !txData.result.result) {
+        throw new Error('[Sun.io] Failed to build swap transaction');
+    }
+    return txData.transaction;
+};

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

@@ -0,0 +1,6 @@
+export declare const SUNIO_SUPPORTED_CHAIN_IDS: readonly [import("@shapeshiftoss/caip").ChainId];
+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_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

@@ -0,0 +1,13 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+export const SUNIO_SUPPORTED_CHAIN_IDS = [tronChainId];
+// NOTE: This domain looks suspicious, but it's the official Sun.io backend API
+// Verified by inspecting XHR requests from sun.io's own frontend application
+// The sun.io frontend makes requests to this endpoint with origin: https://sun.io
+export const SUNIO_API_BASE_URL = 'https://rot.endjgfsv.link';
+// Smart Exchange Router - aggregates liquidity across V1, V2, V3, PSM, and SunCurve
+// 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';
+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/fetchFromSunio.d.ts

@@ -0,0 +1,11 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { SunioQuoteResponse } from '../types.js';
+import type { SunioService } from './sunioService.js';
+export type FetchSunioQuoteParams = {
+    sellAssetId: AssetId;
+    buyAssetId: AssetId;
+    sellAmountCryptoBaseUnit: string;
+};
+export declare const fetchSunioQuote: (params: FetchSunioQuoteParams, service: SunioService) => Promise<Result<SunioQuoteResponse, SwapErrorRight>>;

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

@@ -0,0 +1,41 @@
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { SUNIO_API_BASE_URL, SUNIO_DEX_TYPES } from './constants.js';
+import { assetIdToTronToken } from './helpers/helpers.js';
+export const fetchSunioQuote = async (params, service) => {
+    try {
+        const { sellAssetId, buyAssetId, sellAmountCryptoBaseUnit } = params;
+        const fromToken = assetIdToTronToken(sellAssetId);
+        const toToken = assetIdToTronToken(buyAssetId);
+        const queryParams = {
+            fromToken,
+            toToken,
+            amountIn: sellAmountCryptoBaseUnit,
+            typeList: SUNIO_DEX_TYPES,
+        };
+        const url = `${SUNIO_API_BASE_URL}/swap/router`;
+        const maybeResponse = await service.get(url, {
+            params: queryParams,
+        });
+        if (maybeResponse.isErr()) {
+            return Err(maybeResponse.unwrapErr());
+        }
+        const { data: response } = maybeResponse.unwrap();
+        if (response.code !== 0 || !response.data || response.data.length === 0) {
+            return Err(makeSwapErrorRight({
+                message: `[Sun.io] ${response.message || 'No routes found'}`,
+                code: TradeQuoteError.NoRouteFound,
+                details: { response },
+            }));
+        }
+        return Ok(response);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: '[Sun.io] Failed to fetch quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};

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

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, GetTradeRateInput, GetTronTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
+export declare function getQuoteOrRate(input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps): Promise<Result<TradeQuote, SwapErrorRight>>;
+export declare function getQuoteOrRate(input: GetTradeRateInput, deps: SwapperDeps): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,199 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { 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 { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
+import { fetchSunioQuote } from './fetchFromSunio.js';
+import { isSupportedChainId } from './helpers/helpers.js';
+import { sunioServiceFactory } from './sunioService.js';
+export async function getQuoteOrRate(input, deps) {
+    try {
+        const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+        const { assertGetTronChainAdapter: _assertGetTronChainAdapter } = deps;
+        if (!isSupportedChainId(sellAsset.chainId)) {
+            return Err(makeSwapErrorRight({
+                message: `[${SwapperName.Sunio}] Unsupported chainId: ${sellAsset.chainId}`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAsset.chainId },
+            }));
+        }
+        if (sellAsset.chainId !== buyAsset.chainId) {
+            return Err(makeSwapErrorRight({
+                message: `[${SwapperName.Sunio}] Cross-chain not supported`,
+                code: TradeQuoteError.CrossChainNotSupported,
+            }));
+        }
+        if (sellAsset.chainId !== tronChainId) {
+            return Err(makeSwapErrorRight({
+                message: `[${SwapperName.Sunio}] Only TRON chain supported`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+        }
+        const service = sunioServiceFactory();
+        const maybeQuoteResponse = await fetchSunioQuote({
+            sellAssetId: sellAsset.assetId,
+            buyAssetId: buyAsset.assetId,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        }, service);
+        if (maybeQuoteResponse.isErr()) {
+            return Err(maybeQuoteResponse.unwrapErr());
+        }
+        const quoteResponse = maybeQuoteResponse.unwrap();
+        const bestRoute = quoteResponse.data[0];
+        if (!bestRoute) {
+            return Err(makeSwapErrorRight({
+                message: '[Sun.io] No routes available',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const isQuote = input.quoteOrRate === 'quote';
+        // For quotes, receiveAddress is required
+        if (isQuote && !receiveAddress) {
+            return Err(makeSwapErrorRight({
+                message: '[Sun.io] receiveAddress is required for quotes',
+                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) {
+            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);
+                }
+            }
+            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;
+                }
+            }
+        }
+        const buyAmountCryptoBaseUnit = bn(bestRoute.amountOut)
+            .times(bn(10).pow(buyAsset.precision))
+            .toFixed(0);
+        // Calculate protocol fees only for quotes
+        const protocolFeeCryptoBaseUnit = isQuote
+            ? bn(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)
+            : '0';
+        const buyAmountAfterFeesCryptoBaseUnit = buyAmountCryptoBaseUnit;
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const trade = {
+            id: crypto.randomUUID(),
+            quoteOrRate: input.quoteOrRate,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? DEFAULT_SLIPPAGE_PERCENTAGE,
+            receiveAddress,
+            affiliateBps,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: protocolFeeCryptoBaseUnit !== '0'
+                            ? {
+                                [sellAsset.assetId]: {
+                                    amountCryptoBaseUnit: protocolFeeCryptoBaseUnit,
+                                    requiresBalance: false,
+                                    asset: sellAsset,
+                                },
+                            }
+                            : {},
+                    },
+                    rate,
+                    source: SwapperName.Sunio,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: SUNIO_SMART_ROUTER_CONTRACT,
+                    estimatedExecutionTimeMs: undefined,
+                    ...(isQuote && {
+                        sunioTransactionMetadata: {
+                            route: bestRoute,
+                        },
+                    }),
+                },
+            ],
+            swapperName: SwapperName.Sunio,
+        };
+        return Ok(trade);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: `[Sun.io] Failed to get trade ${input.quoteOrRate}`,
+            code: TradeQuoteError.UnknownError,
+            cause: error,
+        }));
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { AssetId } 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 import("@shapeshiftoss/caip").ChainId;

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

@@ -0,0 +1,16 @@
+import { fromAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { isToken } from '@shapeshiftoss/utils';
+import { SUNIO_SUPPORTED_CHAIN_IDS, SUNIO_TRON_NATIVE_ADDRESS } from '../constants.js';
+export const isSupportedChainId = (chainId) => {
+    return SUNIO_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+export const assetIdToTronToken = (assetId) => {
+    if (isToken(assetId)) {
+        const { assetReference } = fromAssetId(assetId);
+        return assetReference;
+    }
+    return SUNIO_TRON_NATIVE_ADDRESS;
+};
+export const isTronChainId = (chainId) => {
+    return chainId === tronChainId;
+};

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

@@ -0,0 +1,6 @@
+export declare const sunioServiceFactory: () => {
+    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/SunioSwapper/utils/sunioService.js

@@ -0,0 +1,14 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAge = 5 * 1000;
+const cachedUrls = ['/swap/router'];
+export const sunioServiceFactory = () => {
+    const axiosConfig = {
+        timeout: 10000,
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+    };
+    const serviceBase = createCache(maxAge, cachedUrls, axiosConfig);
+    return makeSwapperAxiosServiceMonadic(serviceBase);
+};

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

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

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

@@ -1,5 +1,5 @@
 import { cosmosAssetId, rujiAssetId, tcyAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
-import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, utxo, } from '../../thorchain-utils/index.js';
+import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, tron, utxo, } from '../../thorchain-utils/index.js';
 import { SwapperName } from '../../types.js';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
@@ -12,6 +12,8 @@ export const thorchainApi = {
     getEvmTransactionFees: input => evm.getEvmTransactionFees(input, swapperName),
     getUnsignedUtxoTransaction: input => utxo.getUnsignedUtxoTransaction(input, swapperName),
     getUtxoTransactionFees: input => utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedTronTransaction: input => tron.getUnsignedTronTransaction(input, swapperName),
+    getTronTransactionFees: input => tron.getTronTransactionFees(input, swapperName),
     getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');

package/dist/esm/swappers/ThorchainSwapper/generated/generatedTradableAssetMap.json

@@ -25,7 +25,6 @@
     "ETH.GUSD-0X056FD409E1D7A124BD7017459DFEA2F387B6D5CD": "eip155:1/erc20:0x056fd409e1d7a124bd7017459dfea2f387b6d5cd",
     "ETH.LINK-0X514910771AF9CA656AF840DFF83E8264ECF986CA": "eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca",
     "ETH.LUSD-0X5F98805A4E8BE255A32880FDEC7F6728C6568BA0": "eip155:1/erc20:0x5f98805a4e8be255a32880fdec7f6728c6568ba0",
-    "ETH.RAZE-0X5EAA69B29F99C84FE5DE8200340B4E9B4AB38EAC": "eip155:1/erc20:0x5eaa69b29f99c84fe5de8200340b4e9b4ab38eac",
     "ETH.SNX-0XC011A73EE8576FB46F5E1C5751CA3B9FE0AF2A6F": "eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f",
     "ETH.TGT-0X108A850856DB3F85D0269A2693D896B394C80325": "eip155:1/erc20:0x108a850856db3f85d0269a2693d896b394c80325",
     "ETH.THOR-0XA5F2211B9B8170F694421F2046281775E8468044": "eip155:1/erc20:0xa5f2211b9b8170f694421f2046281775e8468044",
@@ -34,12 +33,13 @@
     "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7": "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7",
     "ETH.VTHOR-0X815C23ECA83261B6EC689B60CC4A58B54BC24D8D": "eip155:1/erc20:0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
     "ETH.WBTC-0X2260FAC5E5542A773AA44FBCFEDF7C193BC2C599": "eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
-    "ETH.XDEFI-0X72B886D09C117654AB7DA13A14D603001DE0B777": "eip155:1/erc20:0x72b886d09c117654ab7da13a14d603001de0b777",
     "ETH.XRUNE-0X69FA0FEE221AD11012BAB0FDB45D444D3D2CE71C": "eip155:1/erc20:0x69fa0fee221ad11012bab0fdb45d444d3d2ce71c",
     "ETH.YFI-0X0BC529C00C6401AEF6D220BE8C6EA1667F6AD93E": "eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e",
     "GAIA.ATOM": "cosmos:cosmoshub-4/slip44:118",
     "LTC.LTC": "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2",
     "THOR.RUJI": "cosmos:thorchain-1/slip44:ruji",
     "THOR.TCY": "cosmos:thorchain-1/slip44:tcy",
+    "TRON.TRX": "tron:0x2b6653dc/slip44:195",
+    "TRON.USDT-TR7NHQJEKQXGTCI8Q8ZY4PL8OTSZGJLJ6T": "tron:0x2b6653dc/trc20:tr7nhqjekqxgtci8q8zy4pl8otszgjlj6t",
     "THOR.RUNE": "cosmos:thorchain-1/slip44:931"
 }

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

@@ -1,6 +1,6 @@
-import { arbitrumAssetId, avalancheAssetId, baseAssetId, bscAssetId, ethAssetId, fromAssetId, gnosisAssetId, optimismAssetId, polygonAssetId, } from '@shapeshiftoss/caip';
+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_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, isTreasuryChainId, } from '@shapeshiftoss/utils';
+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_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, isTreasuryChainId, } from '@shapeshiftoss/utils';
 export const isNativeEvmAsset = (assetId) => {
     const { chainId } = fromAssetId(assetId);
     switch (chainId) {
@@ -20,6 +20,12 @@ export const isNativeEvmAsset = (assetId) => {
             return assetId === arbitrumAssetId;
         case KnownChainIds.BaseMainnet:
             return assetId === baseAssetId;
+        case KnownChainIds.MonadMainnet:
+            return assetId === monadAssetId;
+        case KnownChainIds.PlasmaMainnet:
+            return assetId === plasmaAssetId;
+        case KnownChainIds.KatanaMainnet:
+            return assetId === katanaAssetId;
         default:
             return false;
     }
@@ -35,6 +41,7 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [KnownChainIds.BaseMainnet]: DAO_TREASURY_BASE,
     [KnownChainIds.SolanaMainnet]: DAO_TREASURY_SOLANA,
     [KnownChainIds.BitcoinMainnet]: DAO_TREASURY_BITCOIN,
+    [KnownChainIds.StarknetMainnet]: DAO_TREASURY_STARKNET,
 };
 export const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = isTreasuryChainId(chainId) ? chainId : undefined;

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

@@ -1,7 +1,8 @@
 import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
 import * as adapters from '@shapeshiftoss/chain-adapters';
-import { assertUnreachable, bn, bnOrZero, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
+import { assertUnreachable, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
+import { TronWeb } from 'tronweb';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
 import { TradeQuoteError } from '../types.js';
@@ -10,6 +11,7 @@ import * as evm from './evm/index.js';
 import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
 import { getQuote } from './getQuote.js';
 import { addLimitToMemo, assertAndProcessMemo, getAffiliate, getNativePrecision, getSwapSource, } from './index.js';
+import * as tron from './tron/index.js';
 import * as utxo from './utxo/index.js';
 const SAFE_GAS_LIMIT = '100000'; // depositWithExpiry()
 export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
@@ -273,10 +275,73 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             }));
         }
         case CHAIN_NAMESPACE.Tron: {
-            return Err(makeSwapErrorRight({
-                message: 'Tron is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
+            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) {
+                    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 });
+                        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;
+                        let totalFee = 0;
+                        if (contractAddress) {
+                            // TRC20: Estimate energy with actual recipient
+                            try {
+                                const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
+                                    { type: 'address', value: vault },
+                                    { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+                                ], input.receiveAddress);
+                                const energyUsed = result.energy_used ?? 65000;
+                                const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
+                                const bandwidthFee = 276 * bandwidthPrice; // TRC20 bandwidth
+                                totalFee = Math.ceil(energyFee + bandwidthFee);
+                            }
+                            catch {
+                                // Fallback: Conservative estimate
+                                totalFee = 13_000_000; // 13 TRX worst case
+                            }
+                        }
+                        else {
+                            // TRX transfer bandwidth: Base tx + memo bytes
+                            const baseBytes = 198;
+                            const memoBytes = route.quote.memo
+                                ? Buffer.from(route.quote.memo, 'utf8').length
+                                : 0;
+                            const totalBandwidth = baseBytes + memoBytes;
+                            totalFee = totalBandwidth * bandwidthPrice;
+                        }
+                        networkFeeCryptoBaseUnit = String(totalFee);
+                    }
+                    catch {
+                        // Leave as undefined if estimation fails
+                    }
+                }
+                // For quotes, fees will be calculated in getTronTransactionFees when executing
+                return Promise.resolve(makeThorTradeRateOrQuote({
+                    route,
+                    allowanceContract: '0x0',
+                    memo,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: getProtocolFees(route.quote),
+                    },
+                }));
             }));
+            const routes = maybeRoutes.filter(isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return Err(makeSwapErrorRight({
+                    message: 'Unable to create any routes',
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return Ok(routes);
         }
         case CHAIN_NAMESPACE.Sui: {
             return Err(makeSwapErrorRight({
@@ -284,6 +349,18 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 code: TradeQuoteError.UnsupportedTradePair,
             }));
         }
+        case CHAIN_NAMESPACE.Near: {
+            return Err(makeSwapErrorRight({
+                message: 'NEAR is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case CHAIN_NAMESPACE.Starknet: {
+            return Err(makeSwapErrorRight({
+                message: 'Starknet is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
         default:
             return assertUnreachable(chainNamespace);
     }

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

@@ -13,6 +13,7 @@ export * from './getL1RateOrQuote.js';
 export * from './getPoolDetails.js';
 export * as cosmossdk from './cosmossdk/index.js';
 export * as evm from './evm/index.js';
+export * as tron from './tron/index.js';
 export * as utxo from './utxo/index.js';
 export declare const getChainIdBySwapper: (swapperName: SwapperName) => import("@shapeshiftoss/caip").ChainId;
 export declare const isThorTradeRate: (quote: TradeRate | undefined) => quote is ThorTradeRate;

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

@@ -14,6 +14,7 @@ export * from './getL1RateOrQuote.js';
 export * from './getPoolDetails.js';
 export * as cosmossdk from './cosmossdk/index.js';
 export * as evm from './evm/index.js';
+export * as tron from './tron/index.js';
 export * as utxo from './utxo/index.js';
 export const getChainIdBySwapper = (swapperName) => {
     switch (swapperName) {

package/dist/esm/thorchain-utils/tron/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/tron/getThorTxData.js

@@ -0,0 +1,10 @@
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getDaemonUrl } from '../index.js';
+export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, false, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    const { address: vault } = res.unwrap();
+    return { vault };
+};

package/dist/esm/thorchain-utils/tron/getTronTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs, SwapperName } from '../../types.js';
+export declare const getTronTransactionFees: (args: GetUnsignedTronTransactionArgs, swapperName: SwapperName) => Promise<string>;