@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.7

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.js

@@ -5,7 +5,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
 import { QuoteRequest } from '../types.js';
@@ -36,11 +36,16 @@ export const getTradeQuote = async (input, deps) => {
         initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
         const originAsset = await assetToNearIntentsAsset(sellAsset);
         const destinationAsset = await assetToNearIntentsAsset(buyAsset);
-        // This shouldn't be the case since we already got a rate and know these exist, but...
-        if (!(originAsset && destinationAsset)) {
+        if (!originAsset) {
             return Err(makeSwapErrorRight({
                 code: TradeQuoteError.UnsupportedTradePair,
-                message: 'Unsupported asset',
+                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        if (!destinationAsset) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
             }));
         }
         const quoteRequest = {
@@ -138,6 +143,30 @@ export const getTradeQuote = async (input, deps) => {
                     const totalFee = bn(txFee).plus(ataCreationCost).toString();
                     return { networkFeeCryptoBaseUnit: totalFee };
                 }
+                case CHAIN_NAMESPACE.Tron: {
+                    const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                    });
+                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
+                }
+                case CHAIN_NAMESPACE.Sui: {
+                    const sellAdapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+                    const tokenId = isToken(sellAsset.assetId)
+                        ? fromAssetId(sellAsset.assetId).assetReference
+                        : undefined;
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: {
+                            from,
+                            tokenId,
+                        },
+                        sendMax: false,
+                    });
+                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
+                }
                 default:
                     throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
             }
@@ -188,13 +217,24 @@ export const getTradeQuote = async (input, deps) => {
     }
     catch (error) {
         console.error('[NEAR Intents] getTradeQuote error:', error);
-        if (error instanceof ApiError &&
-            (error.body?.message === 'tokenIn is not valid' ||
-                error.body?.message === 'tokenOut is not valid')) {
-            return Err(makeSwapErrorRight({
-                code: TradeQuoteError.UnsupportedTradePair,
-                message: 'Unsupported asset',
-            }));
+        if (error instanceof ApiError) {
+            if (error.body?.message === 'tokenIn is not valid' ||
+                error.body?.message === 'tokenOut is not valid') {
+                return Err(makeSwapErrorRight({
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    message: 'Unsupported asset',
+                }));
+            }
+            if (error.body?.message?.includes('Amount is too low')) {
+                const match = error.body.message.match(/try at least (\d+)/);
+                if (match) {
+                    const minAmountCryptoBaseUnit = match[1];
+                    return Err(createTradeAmountTooSmallErr({
+                        minAmountCryptoBaseUnit,
+                        assetId: sellAsset.assetId,
+                    }));
+                }
+            }
         }
         return Err(makeSwapErrorRight({
             message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents quote',

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -6,7 +6,7 @@ import { v4 as uuid } from 'uuid';
 import { getAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
 import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS } from '../constants.js';
@@ -19,10 +19,18 @@ export const getTradeRate = async (input, deps) => {
         initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
         const originAsset = await assetToNearIntentsAsset(sellAsset);
         const destinationAsset = await assetToNearIntentsAsset(buyAsset);
-        if (!(originAsset && destinationAsset)) {
+        if (!originAsset) {
+            console.log('[NEAR] Returning error - originAsset not supported');
             return Err(makeSwapErrorRight({
                 code: TradeQuoteError.UnsupportedTradePair,
-                message: 'Unsupported asset',
+                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        if (!destinationAsset) {
+            console.log('[NEAR] Returning error - destinationAsset not supported');
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
             }));
         }
         // Wallet connected: use actual addresses
@@ -145,6 +153,43 @@ export const getTradeRate = async (input, deps) => {
                         return '0';
                     }
                 }
+                case CHAIN_NAMESPACE.Tron: {
+                    try {
+                        const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                case CHAIN_NAMESPACE.Sui: {
+                    try {
+                        const sellAdapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+                        const tokenId = isToken(sellAsset.assetId)
+                            ? fromAssetId(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenId,
+                            },
+                            sendMax: false,
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
                 default:
                     return undefined;
             }
@@ -187,13 +232,24 @@ export const getTradeRate = async (input, deps) => {
         return Ok([tradeRate]);
     }
     catch (error) {
-        if (error instanceof ApiError &&
-            (error.body?.message === 'tokenIn is not valid' ||
-                error.body?.message === 'tokenOut is not valid')) {
-            return Err(makeSwapErrorRight({
-                code: TradeQuoteError.UnsupportedTradePair,
-                message: 'Unsupported asset',
-            }));
+        if (error instanceof ApiError) {
+            if (error.body?.message === 'tokenIn is not valid' ||
+                error.body?.message === 'tokenOut is not valid') {
+                return Err(makeSwapErrorRight({
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    message: 'Unsupported asset',
+                }));
+            }
+            if (error.body?.message?.includes('Amount is too low')) {
+                const match = error.body.message.match(/try at least (\d+)/);
+                if (match) {
+                    const minAmountCryptoBaseUnit = match[1];
+                    return Err(createTradeAmountTooSmallErr({
+                        minAmountCryptoBaseUnit,
+                        assetId: sellAsset.assetId,
+                    }));
+                }
+            }
         }
         return Err(makeSwapErrorRight({
             message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents rate',

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

@@ -1,6 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
-export type { QuoteResponse, GetExecutionStatusResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
-export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.SolanaMainnet];
+export type { GetExecutionStatusResponse, QuoteResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet];
 export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
 export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

package/dist/esm/swappers/NearIntentsSwapper/types.js

@@ -12,6 +12,8 @@ export const nearIntentsSupportedChainIds = [
     KnownChainIds.BitcoinMainnet,
     KnownChainIds.DogecoinMainnet,
     KnownChainIds.SolanaMainnet,
+    KnownChainIds.TronMainnet,
+    KnownChainIds.SuiMainnet,
 ];
 export const chainIdToNearIntentsChain = {
     [KnownChainIds.EthereumMainnet]: 'eth',
@@ -25,4 +27,6 @@ export const chainIdToNearIntentsChain = {
     [KnownChainIds.BitcoinMainnet]: 'btc',
     [KnownChainIds.DogecoinMainnet]: 'doge',
     [KnownChainIds.SolanaMainnet]: 'sol',
+    [KnownChainIds.TronMainnet]: 'tron',
+    [KnownChainIds.SuiMainnet]: 'sui',
 };

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

@@ -1,5 +1,5 @@
 import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
-import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
+import { fromAssetId, solanaChainId, suiChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { bnOrZero, isToken } from '@shapeshiftoss/utils';
 import { zeroAddress } from 'viem';
@@ -23,19 +23,23 @@ export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
-const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op'];
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron'];
+const TOKEN_LOOKUP_CHAINS = ['sui'];
 export const assetToNearIntentsAsset = async (asset) => {
     const nearNetwork = chainIdToNearIntentsChain[asset.chainId];
     if (!nearNetwork)
         return null;
-    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism) and Solana require token lookup
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, SUI) and Solana require token lookup
     // Asset IDs use hashed format that can't be generated from contract addresses
-    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) || asset.chainId === solanaChainId;
+    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) ||
+        TOKEN_LOOKUP_CHAINS.includes(nearNetwork) ||
+        asset.chainId === solanaChainId ||
+        asset.chainId === suiChainId;
     if (requiresLookup) {
         const tokens = await OneClickService.getTokens();
-        const contractAddress = isToken(asset.assetId)
-            ? fromAssetId(asset.assetId).assetReference.toLowerCase()
-            : null;
+        const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
+        const isNativeAsset = assetNamespace === 'slip44';
+        const contractAddress = !isNativeAsset ? assetReference.toLowerCase() : null;
         const match = tokens.find((t) => {
             if (t.blockchain !== nearNetwork)
                 return false;
@@ -43,8 +47,9 @@ export const assetToNearIntentsAsset = async (asset) => {
                 ? t.contractAddress?.toLowerCase() === contractAddress
                 : !t.contractAddress;
         });
-        if (!match)
+        if (!match) {
             return null;
+        }
         return match.assetId;
     }
     // NEP-141 chains (ETH, ARB, BASE, GNOSIS, BTC, DOGE): use predictable format

package/dist/esm/swappers/RelaySwapper/RelaySwapper.js

@@ -1,7 +1,8 @@
-import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
 export const relaySwapper = {
     executeEvmTransaction,
     executeSolanaTransaction,
+    executeTronTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

package/dist/esm/swappers/RelaySwapper/constant.d.ts

@@ -1,7 +1,5 @@
-import { KnownChainIds } from '@shapeshiftoss/types';
 import { TradeQuoteError } from '../../types.js';
 import { RelayErrorCode } from './utils/types.js';
-export declare const relaySupportedChainIds: KnownChainIds[];
 export declare const chainIdToRelayChainId: {
     [x: string]: number;
 };
@@ -16,8 +14,10 @@ export declare const relayChainIdToChainId: import("lodash").Dictionary<string>;
 export declare const DEFAULT_RELAY_EVM_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
 export declare const RELAY_BTC_TOKEN_ADDRESS = "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
 export declare const RELAY_SOLANA_TOKEN_ADDRESS = "11111111111111111111111111111111";
+export declare const RELAY_TRON_TOKEN_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
 export declare const DEFAULT_RELAY_EVM_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
 export declare const DEFAULT_RELAY_BTC_USER_ADDRESS = "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa";
 export declare const DEFAULT_RELAY_SOLANA_USER_ADDRESS = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
+export declare const DEFAULT_RELAY_TRON_USER_ADDRESS = "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";
 export declare const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
 export declare const relayErrorCodeToTradeQuoteError: Record<RelayErrorCode, TradeQuoteError>;

package/dist/esm/swappers/RelaySwapper/constant.js

@@ -1,22 +1,9 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, optimismChainId, polygonChainId, solanaChainId, } from '@shapeshiftoss/caip';
-import { KnownChainIds } from '@shapeshiftoss/types';
+import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, monadChainId, optimismChainId, polygonChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, avalanche, base, bsc, gnosis, mainnet as ethereum, optimism, polygon, } from 'viem/chains';
+import { arbitrum, avalanche, base, bsc, gnosis, mainnet as ethereum, monad, optimism, polygon, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { RelayErrorCode } from './utils/types.js';
-export const relaySupportedChainIds = [
-    KnownChainIds.EthereumMainnet,
-    KnownChainIds.ArbitrumMainnet,
-    KnownChainIds.BaseMainnet,
-    KnownChainIds.OptimismMainnet,
-    KnownChainIds.PolygonMainnet,
-    KnownChainIds.GnosisMainnet,
-    KnownChainIds.AvalancheMainnet,
-    KnownChainIds.BitcoinMainnet,
-    KnownChainIds.SolanaMainnet,
-    KnownChainIds.BnbSmartChainMainnet,
-];
 export const chainIdToRelayChainId = {
     // https://docs.relay.link/resources/supported-chains
     [btcChainId]: 8253038,
@@ -30,6 +17,8 @@ export const chainIdToRelayChainId = {
     [gnosisChainId]: gnosis.id,
     [avalancheChainId]: avalanche.id,
     [bscChainId]: bsc.id,
+    [tronChainId]: 728126428,
+    [monadChainId]: monad.id,
 };
 export var RelayStatusMessage;
 (function (RelayStatusMessage) {
@@ -43,9 +32,11 @@ export const relayChainIdToChainId = invert(chainIdToRelayChainId);
 export const DEFAULT_RELAY_EVM_TOKEN_ADDRESS = zeroAddress;
 export const RELAY_BTC_TOKEN_ADDRESS = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
 export const RELAY_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
+export const RELAY_TRON_TOKEN_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
 export const DEFAULT_RELAY_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
 export const DEFAULT_RELAY_BTC_USER_ADDRESS = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
 export const DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
+export const DEFAULT_RELAY_TRON_USER_ADDRESS = 'TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy';
 export const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
 export const relayErrorCodeToTradeQuoteError = {
     [RelayErrorCode.AmountTooLow]: TradeQuoteError.SellAmountBelowMinimum,

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

@@ -3,6 +3,8 @@ import { TxStatus } from '@shapeshiftoss/unchained-client';
 import BigNumber from 'bignumber.js';
 import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
 import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
+import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
 import { checkSafeTransactionStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
 import { chainIdToRelayChainId } from './constant.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
@@ -119,6 +121,8 @@ export const relayApi = {
     },
     getSolanaTransactionFees,
     getUnsignedSolanaTransaction,
+    getTronTransactionFees,
+    getUnsignedTronTransaction,
     checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
         const maybeSafeTransactionStatus = await checkSafeTransactionStatus({
             txHash,

package/dist/esm/swappers/RelaySwapper/utils/getRelayAssetAddress.js

@@ -1,11 +1,13 @@
-import { btcAssetId, fromAssetId, isAssetReference, solAssetId } from '@shapeshiftoss/caip';
+import { btcAssetId, fromAssetId, isAssetReference, solAssetId, tronAssetId, } from '@shapeshiftoss/caip';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, } from '../constant.js';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_TOKEN_ADDRESS, } from '../constant.js';
 export const getRelayAssetAddress = (asset) => {
     if (asset.assetId === btcAssetId)
         return RELAY_BTC_TOKEN_ADDRESS;
     if (asset.assetId === solAssetId)
         return RELAY_SOLANA_TOKEN_ADDRESS;
+    if (asset.assetId === tronAssetId)
+        return RELAY_TRON_TOKEN_ADDRESS;
     if (isNativeEvmAsset(asset.assetId))
         return DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
     const { assetReference } = fromAssetId(asset.assetId);

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.d.ts

@@ -1,2 +1,2 @@
 import type { ChainId } from '@shapeshiftoss/caip';
-export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
+export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.js

@@ -1,11 +1,13 @@
-import { btcChainId, solanaChainId } from '@shapeshiftoss/caip';
-import { DEFAULT_RELAY_BTC_USER_ADDRESS, DEFAULT_RELAY_EVM_USER_ADDRESS, DEFAULT_RELAY_SOLANA_USER_ADDRESS, } from '../constant.js';
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { DEFAULT_RELAY_BTC_USER_ADDRESS, DEFAULT_RELAY_EVM_USER_ADDRESS, DEFAULT_RELAY_SOLANA_USER_ADDRESS, DEFAULT_RELAY_TRON_USER_ADDRESS, } from '../constant.js';
 export const getRelayDefaultUserAddress = (chainId) => {
     switch (chainId) {
         case btcChainId:
             return DEFAULT_RELAY_BTC_USER_ADDRESS;
         case solanaChainId:
             return DEFAULT_RELAY_SOLANA_USER_ADDRESS;
+        case tronChainId:
+            return DEFAULT_RELAY_TRON_USER_ADDRESS;
         default:
             return DEFAULT_RELAY_EVM_USER_ADDRESS;
     }

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.js

@@ -9,7 +9,7 @@ export const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
         try {
             const address = bitcoin.address.fromOutputScript(script);
             // Assuming the destination address is the one with the exact amount of sellAmountCryptoBaseUnit
-            if (output.value === Number(sellAmountCryptoBaseUnit)) {
+            if (output.value === BigInt(sellAmountCryptoBaseUnit)) {
                 return address;
             }
         }

package/dist/esm/swappers/RelaySwapper/utils/getTrade.js

@@ -1,4 +1,4 @@
-import { btcChainId, fromChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { btcChainId, fromChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
@@ -26,7 +26,8 @@ export async function getTrade({ input, deps, relayChainMap, }) {
     const buyRelayChainId = relayChainMap[buyAsset.chainId];
     if (!isEvmChainId(sellAsset.chainId) &&
         sellAsset.chainId !== btcChainId &&
-        sellAsset.chainId !== solanaChainId) {
+        sellAsset.chainId !== solanaChainId &&
+        sellAsset.chainId !== tronChainId) {
         return Err(makeSwapErrorRight({
             message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
             code: TradeQuoteError.UnsupportedTradePair,
@@ -34,7 +35,8 @@ export async function getTrade({ input, deps, relayChainMap, }) {
     }
     if (!isEvmChainId(buyAsset.chainId) &&
         buyAsset.chainId !== btcChainId &&
-        buyAsset.chainId !== solanaChainId) {
+        buyAsset.chainId !== solanaChainId &&
+        buyAsset.chainId !== tronChainId) {
         return Err(makeSwapErrorRight({
             message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
             code: TradeQuoteError.UnsupportedTradePair,
@@ -211,6 +213,9 @@ export async function getTrade({ input, deps, relayChainMap, }) {
         if (sellAsset.chainId === solanaChainId) {
             return sellAsset.assetId === appFeesAsset.assetId;
         }
+        if (sellAsset.chainId === tronChainId) {
+            return sellAsset.assetId === appFeesAsset.assetId;
+        }
         return false;
     })();
     const appFeesBaseUnit = (() => {

package/dist/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -1,6 +1,6 @@
-import { ASSET_NAMESPACE, ASSET_REFERENCE, btcChainId, CHAIN_REFERENCE, fromChainId, solanaChainId, toAssetId, } from '@shapeshiftoss/caip';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, btcChainId, CHAIN_REFERENCE, fromChainId, solanaChainId, toAssetId, tronChainId, } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, relayChainIdToChainId, } from '../constant.js';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_TOKEN_ADDRESS, relayChainIdToChainId, } from '../constant.js';
 export const relayTokenToAssetId = (relayToken) => {
     const chainId = relayChainIdToChainId[relayToken.chainId];
     const { chainReference } = fromChainId(chainId);
@@ -14,6 +14,9 @@ export const relayTokenToAssetId = (relayToken) => {
         if (chainId === solanaChainId) {
             return relayToken.address === RELAY_SOLANA_TOKEN_ADDRESS;
         }
+        if (chainId === tronChainId) {
+            return relayToken.address === RELAY_TRON_TOKEN_ADDRESS;
+        }
         return false;
     })();
     const { assetReference, assetNamespace } = (() => {
@@ -24,6 +27,8 @@ export const relayTokenToAssetId = (relayToken) => {
                         return ASSET_NAMESPACE.erc20;
                     case CHAIN_REFERENCE.SolanaMainnet === chainReference:
                         return ASSET_NAMESPACE.splToken;
+                    case CHAIN_REFERENCE.TronMainnet === chainReference:
+                        return ASSET_NAMESPACE.trc20;
                     default:
                         throw Error(`chainReference '${chainReference}' not supported`);
                 }
@@ -79,6 +84,16 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Solana,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
+            case CHAIN_REFERENCE.TronMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Tron,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.MonadMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Monad,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${relayToken.chainId}' not supported`);
         }

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

@@ -272,6 +272,18 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 code: TradeQuoteError.UnsupportedTradePair,
             }));
         }
+        case CHAIN_NAMESPACE.Tron: {
+            return Err(makeSwapErrorRight({
+                message: 'Tron is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case CHAIN_NAMESPACE.Sui: {
+            return Err(makeSwapErrorRight({
+                message: 'SUI is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
         default:
             return assertUnreachable(chainNamespace);
     }

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

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

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

@@ -0,0 +1,10 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getTronTransactionFees = ({ tradeQuote, stepIndex, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    if (!step.feeData.networkFeeCryptoBaseUnit) {
+        throw new Error('Missing network fee in quote');
+    }
+    return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+};

package/dist/esm/tron-utils/getUnsignedTronTransaction.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs } from '../types.js';
+export declare const getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }: GetUnsignedTronTransactionArgs) => Promise<import("packages/chain-adapters/src/tron").TronSignTx>;

package/dist/esm/tron-utils/getUnsignedTronTransaction.js

@@ -0,0 +1,24 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific } = step;
+    const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+    const to = relayTransactionMetadata?.to ?? nearIntentsSpecific?.depositAddress;
+    if (!to)
+        throw new Error('Missing transaction destination address');
+    const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+    // Extract contract address for TRC20 tokens
+    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+    return adapter.buildSendApiTransaction({
+        to,
+        from,
+        value,
+        accountNumber,
+        chainSpecific: {
+            contractAddress,
+        },
+    });
+};