@swapkit/wallets 4.0.0-beta.39 → 4.0.0-beta.41

package/src/bitget/helpers.ts

@@ -6,33 +6,42 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
+import type { TronTransaction } from "@swapkit/toolboxes/tron";
 import { Psbt } from "bitcoinjs-lib";
 import type { Eip1193Provider } from "ethers";
 
 export async function getWalletMethods(chain: Chain) {
+  const { match, P } = await import("ts-pattern");
   const bitget = window.bitkeep;
 
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Base:
-    case Chain.Avalanche:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.BinanceSmartChain: {
-      if (!(bitget && "ethereum" in bitget)) {
-        throw new SwapKitError("wallet_bitkeep_not_found");
-      }
-
-      const wallet = bitget.ethereum;
-
-      const [address]: [string] = await wallet.send("eth_requestAccounts", []);
-      const evmWallet = await getWeb3WalletMethods({ chain, walletProvider: wallet });
-
-      return { ...evmWallet, address };
-    }
-
-    case Chain.Bitcoin: {
+  return match(chain)
+    .with(
+      P.union(
+        Chain.Ethereum,
+        Chain.Base,
+        Chain.Avalanche,
+        Chain.Arbitrum,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.BinanceSmartChain,
+      ),
+      async () => {
+        if (!(bitget && "ethereum" in bitget)) {
+          throw new SwapKitError("wallet_bitkeep_not_found");
+        }
+
+        const wallet = bitget.ethereum;
+
+        const [address]: [string] = await wallet.send("eth_requestAccounts", []);
+        const evmWallet = await getWeb3WalletMethods({
+          chain: chain as EVMChain,
+          walletProvider: wallet,
+        });
+
+        return { ...evmWallet, address };
+      },
+    )
+    .with(Chain.Bitcoin, async () => {
       if (!(bitget && "unisat" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -55,9 +64,8 @@ export async function getWalletMethods(chain: Chain) {
       const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Cosmos: {
+    })
+    .with(Chain.Cosmos, async () => {
       if (!(bitget && "keplr" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -83,9 +91,8 @@ export async function getWalletMethods(chain: Chain) {
       });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Solana: {
+    })
+    .with(Chain.Solana, async () => {
       if (!(bitget && "solana" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -98,11 +105,39 @@ export async function getWalletMethods(chain: Chain) {
       const address: string = providerConnection.publicKey.toString();
 
       return { ...toolbox, address };
-    }
+    })
+    .with(Chain.Tron, async () => {
+      if (!(bitget && "tronLink" in bitget && "tronWeb" in bitget)) {
+        throw new SwapKitError("wallet_bitkeep_not_found");
+      }
+
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const { tronLink, tronWeb } = bitget;
+
+      // Request account access
+      const account = await tronLink.request({ method: "tron_requestAccounts" });
+      if (!account?.base58) {
+        throw new SwapKitError("wallet_bitkeep_no_accounts", { chain: Chain.Tron });
+      }
+
+      const address = account.base58;
+
+      // Create signer compatible with TronSigner interface
+      const signer = {
+        getAddress: () => Promise.resolve(address),
+        signTransaction: async (transaction: TronTransaction) => {
+          const signedTx = await tronWeb.trx.sign(transaction);
+          return signedTx;
+        },
+      };
 
-    default:
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .otherwise(() => {
       throw new SwapKitError("wallet_chain_not_supported");
-  }
+    });
 }
 
 export const getWeb3WalletMethods = async ({

package/src/bitget/index.ts

@@ -12,7 +12,7 @@ import { getWalletMethods } from "./helpers";
 export const bitgetWallet = createWallet({
   name: "connectBitget",
   walletType: WalletOption.BITGET,
-  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana],
+  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana, Chain.Tron],
   connect: ({ addChain, walletType, supportedChains }) =>
     async function connectBitget(chains: Chain[]) {
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });

package/src/keepkey/chains/cosmos.ts

@@ -18,7 +18,7 @@ export const cosmosWalletMethods = async ({
   const {
     DEFAULT_COSMOS_FEE_MAINNET,
     getCosmosToolbox,
-    getFeeRateFromThorswap,
+    getFeeRateFromSwapKit,
     createStargateClient,
   } = await import("@swapkit/toolboxes/cosmos");
   const derivationPathString = derivationPath
@@ -33,7 +33,7 @@ export const cosmosWalletMethods = async ({
 
   if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
     DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-      await getFeeRateFromThorswap(ChainId.Cosmos, 500),
+      await getFeeRateFromSwapKit(ChainId.Cosmos, 500),
     );
   }
 

package/src/ledger/clients/tron.ts

@@ -0,0 +1,92 @@
+import type TronApp from "@ledgerhq/hw-app-trx";
+import {
+  type DerivationPathArray,
+  NetworkDerivationPath,
+  SwapKitError,
+  derivationPathToString,
+} from "@swapkit/helpers";
+import type { TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
+
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+export class TronLedgerInterface implements TronSigner {
+  derivationPath: string;
+  ledgerApp: InstanceType<typeof TronApp> | null = null;
+  ledgerTimeout = 50000;
+
+  constructor(derivationPath?: DerivationPathArray | string) {
+    this.derivationPath =
+      typeof derivationPath === "string"
+        ? derivationPath
+        : derivationPathToString(derivationPath || NetworkDerivationPath.TRX);
+  }
+
+  checkOrCreateTransportAndLedger = async () => {
+    if (this.ledgerApp) return;
+    await this.createTransportAndLedger();
+  };
+
+  createTransportAndLedger = async () => {
+    const transport = await getLedgerTransport();
+    const TronApp = (await import("@ledgerhq/hw-app-trx")).default;
+
+    this.ledgerApp = new TronApp(transport);
+  };
+
+  getAddress = async (): Promise<string> => {
+    const response = await this.getAddressAndPubKey();
+    if (!response) throw new SwapKitError("wallet_ledger_failed_to_get_address");
+    return response.address;
+  };
+
+  getAddressAndPubKey = async () => {
+    await this.createTransportAndLedger();
+    const result = await this.ledgerApp?.getAddress(this.derivationPath);
+
+    if (!result) throw new SwapKitError("wallet_ledger_failed_to_get_address");
+
+    return {
+      address: result.address,
+      publicKey: result.publicKey,
+    };
+  };
+
+  showAddressAndPubKey = async () => {
+    await this.createTransportAndLedger();
+    return this.ledgerApp?.getAddress(this.derivationPath, true);
+  };
+
+  signTransaction = async (transaction: TronTransaction) => {
+    await this.createTransportAndLedger();
+
+    if (!this.ledgerApp) {
+      throw new SwapKitError("wallet_ledger_transport_error");
+    }
+
+    // Tron transactions need to be serialized before signing
+    const serializedTx = JSON.stringify(transaction);
+
+    try {
+      const signature = await this.ledgerApp.signTransaction(
+        this.derivationPath,
+        serializedTx,
+        [], // Token signatures array - empty for native TRX transfers
+      );
+
+      if (!signature) {
+        throw new SwapKitError("wallet_ledger_signing_error");
+      }
+
+      // Return the signed transaction in Tron's expected format
+      return {
+        ...transaction,
+        signature: [signature],
+      };
+    } catch (error) {
+      throw new SwapKitError("wallet_ledger_signing_error", { error });
+    }
+  };
+}
+
+export const TronLedger = (derivationPath?: DerivationPathArray) =>
+  new TronLedgerInterface(derivationPath);

package/src/ledger/helpers/getLedgerAddress.ts

@@ -1,6 +1,7 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
 import type { getNearLedgerClient } from "../clients/near";
+import type { TronLedger } from "../clients/tron";
 import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
 import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
@@ -54,6 +55,10 @@ export const getLedgerAddress = async <
       return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).address;
     }
 
+    case Chain.Tron: {
+      return (ledgerClient as Awaited<ReturnType<typeof TronLedger>>).getAddress();
+    }
+
     default:
       throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.LEDGER, chain });
   }

package/src/ledger/helpers/getLedgerClient.ts

@@ -18,6 +18,7 @@ import {
 } from "../clients/evm";
 import { getNearLedgerClient } from "../clients/near";
 import { THORChainLedger } from "../clients/thorchain";
+import { TronLedger } from "../clients/tron";
 import {
   BitcoinCashLedger,
   BitcoinLedger,
@@ -45,6 +46,7 @@ type LedgerSignerMap = {
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
   [Chain.Ripple]: ReturnType<typeof XRPLedger>;
   [Chain.THORChain]: THORChainLedger;
+  [Chain.Tron]: ReturnType<typeof TronLedger>;
 };
 
 type LedgerSupportedChain = keyof LedgerSignerMap;
@@ -78,6 +80,7 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
       Promise.resolve(LitecoinLedger(derivationPath) as LedgerSignerMap[T]),
     )
     .with(Chain.Ripple, () => Promise.resolve(XRPLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(Chain.Tron, () => Promise.resolve(TronLedger(derivationPath) as LedgerSignerMap[T]))
     .with(Chain.Near, async () => {
       const transport = await getLedgerTransport();
       return getNearLedgerClient(transport, derivationPath) as unknown as LedgerSignerMap[T];

package/src/ledger/index.ts

@@ -36,6 +36,7 @@ export const ledgerWallet = createWallet({
     Chain.Polygon,
     Chain.Ripple,
     Chain.THORChain,
+    Chain.Tron,
   ],
   walletType: WalletOption.LEDGER,
   connect: ({ addChain, supportedChains, walletType }) =>
@@ -288,6 +289,15 @@ async function getWalletMethods({
       return { ...toolbox, address };
     }
 
+    case Chain.Tron: {
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     default:
       throw new SwapKitError("wallet_ledger_chain_not_supported", { chain });
   }

package/src/ledger/types.ts

@@ -9,6 +9,7 @@ import type {
   PolygonLedger,
 } from "./clients/evm";
 import type { THORChainLedger } from "./clients/thorchain";
+import type { TronLedger } from "./clients/tron";
 import type {
   BitcoinCashLedger,
   BitcoinLedger,
@@ -30,6 +31,7 @@ export type EVMLedgerClients =
   | ReturnType<typeof EthereumLedger>
   | ReturnType<typeof OptimismLedger>
   | ReturnType<typeof PolygonLedger>;
+export type TronLedgerClient = ReturnType<typeof TronLedger>;
 
 export type GetAddressAndPubKeyResponse = {
   bech32_address: string;

package/src/okx/helpers.ts

@@ -2,17 +2,19 @@ import {
   Chain,
   ChainId,
   type EVMChain,
+  type GenericTransferParams,
   SKConfig,
   SwapKitError,
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
+import type { TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
 import { Psbt } from "bitcoinjs-lib";
 import type { Eip1193Provider } from "ethers";
 
 const cosmosTransfer =
-  () =>
-  async ({ from, recipient, amount, asset, memo }: any) => {
+  (sender: string) =>
+  async ({ recipient, assetValue, memo }: GenericTransferParams) => {
     if (!(window.okxwallet && "keplr" in window.okxwallet)) {
       throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
     }
@@ -25,12 +27,12 @@ const cosmosTransfer =
 
     const coins = [
       {
-        denom: asset?.symbol === "MUON" ? "umuon" : "uatom",
-        amount: amount.amount().toString(),
+        denom: assetValue?.symbol === "MUON" ? "umuon" : "uatom",
+        amount: assetValue.getBaseValue("string"),
       },
     ];
 
-    const { transactionHash } = await cosmJS.sendTokens(from, recipient, coins, 1.6, memo);
+    const { transactionHash } = await cosmJS.sendTokens(sender, recipient, coins, 1.6, memo);
     return transactionHash;
   };
 
@@ -58,28 +60,34 @@ async function getWeb3WalletMethods({
 }
 
 export async function getWalletMethods(chain: Chain) {
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Base:
-    case Chain.Avalanche:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.BinanceSmartChain: {
-      if (!(window.okxwallet && "send" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain });
-      }
-
-      const evmWallet = await getWeb3WalletMethods({
-        chain,
-        walletProvider: window.okxwallet,
-      });
-      const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
-
-      return { ...evmWallet, address };
-    }
-
-    case Chain.Bitcoin: {
+  const { match, P } = await import("ts-pattern");
+
+  return match(chain)
+    .with(
+      P.union(
+        Chain.Ethereum,
+        Chain.Base,
+        Chain.Avalanche,
+        Chain.Arbitrum,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.BinanceSmartChain,
+      ),
+      async () => {
+        if (!(window.okxwallet && "send" in window.okxwallet)) {
+          throw new SwapKitError("wallet_okx_not_found", { chain });
+        }
+
+        const evmWallet = await getWeb3WalletMethods({
+          chain: chain as EVMChain,
+          walletProvider: window.okxwallet,
+        });
+        const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
+
+        return { ...evmWallet, address };
+      },
+    )
+    .with(Chain.Bitcoin, async () => {
       if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Bitcoin });
       }
@@ -101,12 +109,11 @@ export async function getWalletMethods(chain: Chain) {
         getAddress: async () => Promise.resolve(address),
       };
 
-      const toolbox = await getUtxoToolbox(chain, { signer });
+      const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Cosmos: {
+    })
+    .with(Chain.Cosmos, async () => {
       if (!(window.okxwallet && "keplr" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
       }
@@ -120,10 +127,9 @@ export async function getWalletMethods(chain: Chain) {
       const [{ address }] = accounts;
       const toolbox = getCosmosToolbox(Chain.Cosmos);
 
-      return { ...toolbox, address, transfer: cosmosTransfer() };
-    }
-
-    case Chain.Near: {
+      return { ...toolbox, address, transfer: cosmosTransfer(address) };
+    })
+    .with(Chain.Near, async () => {
       if (!(window.okxwallet && "near" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Near });
       }
@@ -137,9 +143,36 @@ export async function getWalletMethods(chain: Chain) {
       const toolbox = await getNearToolbox({ signer });
 
       return { ...toolbox, address: accountId };
-    }
+    })
+    .with(Chain.Tron, async () => {
+      if (!(window.okxwallet && "tronLink" in window.okxwallet)) {
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Tron });
+      }
 
-    default:
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+
+      const tronLink = window.okxwallet.tronLink;
+
+      // Request account access
+      const accounts = await tronLink.request({ method: "tron_requestAccounts" });
+      if (!accounts || accounts.length === 0) {
+        throw new SwapKitError("wallet_okx_no_accounts", { chain: Chain.Tron });
+      }
+
+      const address = tronLink.tronWeb.defaultAddress.base58;
+
+      const signer: TronSigner = {
+        getAddress: async () => address,
+        signTransaction: async (transaction: TronTransaction) => {
+          return await tronLink.tronWeb.trx.sign(transaction);
+        },
+      };
+
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .otherwise(() => {
       throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
-  }
+    });
 }

package/src/okx/index.ts

@@ -17,6 +17,7 @@ export const okxWallet = createWallet({
     Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Tron,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectOkx(chains: Chain[]) {

package/src/onekey/index.ts

@@ -56,8 +56,8 @@ async function getWalletMethodsForExtension(chain: Chain) {
 
       await getAddress(getAddressOptions);
 
-      async function signTransaction(psbt: any) {
-        let signedPsbt: any;
+      async function signTransaction(psbt: Psbt) {
+        let signedPsbt: Psbt | undefined;
         const signPsbtOptions: SignTransactionOptions = {
           getProvider,
           payload: {

package/src/trezor/index.ts

@@ -112,16 +112,7 @@ async function getTrezorWallet<T extends Chain>({
             amount: value,
             script_type: scriptType.input,
           })),
-
-          // Lint is not happy with the type of txOutputs
-          outputs: psbt.txOutputs.map((output: any) => {
-            const outputAddress =
-              chain === Chain.BitcoinCash && output.address
-                ? toolbox.stripPrefix(toCashAddress(output.address))
-                : output.address;
-
-            const isChangeAddress = outputAddress === address;
-
+          outputs: psbt.txOutputs.map((output) => {
             // OP_RETURN
             if (!output.address) {
               return {
@@ -131,6 +122,13 @@ async function getTrezorWallet<T extends Chain>({
               };
             }
 
+            const outputAddress =
+              chain === Chain.BitcoinCash
+                ? toolbox.stripPrefix(toCashAddress(output.address))
+                : output.address;
+
+            const isChangeAddress = outputAddress === address;
+
             return isChangeAddress
               ? { amount: output.value, address_n, script_type: scriptType.output }
               : { amount: output.value, address: outputAddress, script_type: "PAYTOADDRESS" };

package/src/types.ts

@@ -30,6 +30,7 @@ import type { radixWallet } from "./radix";
 import type { talismanWallet } from "./talisman";
 import type { trezorWallet } from "./trezor";
 import type { walletconnectWallet } from "./walletconnect";
+import type { xamanWallet } from "./xaman";
 
 export type SKWallets = {
   [WalletOption.BITGET]: typeof bitgetWallet;
@@ -58,6 +59,7 @@ export type SKWallets = {
   [WalletOption.TREZOR]: typeof trezorWallet;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
+  [WalletOption.XAMAN]: typeof xamanWallet;
 };
 
 export type SKConnectWallets = SKWallets[keyof SKWallets];
@@ -89,6 +91,7 @@ export type SKWalletsSupportedChains = {
   [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
+  [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
 };
 
 type UnisatToSignInputs = {
@@ -161,6 +164,22 @@ declare global {
       };
       solana: SolanaProvider;
       ethereum: EthereumWindowProvider;
+      tronLink: {
+        request: (args: { method: string; params?: any }) => Promise<any>;
+        ready: boolean;
+      };
+      tronWeb: {
+        defaultAddress: {
+          base58: string;
+          hex: string;
+        };
+        trx: {
+          sign: (transaction: any) => Promise<any>;
+          sendRawTransaction: (signedTransaction: any) => Promise<any>;
+          getAccount: (address: string) => Promise<any>;
+          getBalance: (address: string) => Promise<number>;
+        };
+      };
     };
 
     okxwallet?:
@@ -207,6 +226,22 @@ declare global {
               transactions: any[];
             }) => Promise<any>;
           };
+          tronLink: {
+            request: (args: { method: string; params?: any }) => Promise<any>;
+            ready: boolean;
+            tronWeb: {
+              defaultAddress: {
+                base58: string;
+                hex: string;
+              };
+              trx: {
+                sign: (transaction: any) => Promise<any>;
+                sendRawTransaction: (signedTransaction: any) => Promise<any>;
+                getAccount: (address: string) => Promise<any>;
+                getBalance: (address: string) => Promise<number>;
+              };
+            };
+          };
         }
       | EthereumWindowProvider;
   }

package/src/utils.ts

@@ -52,6 +52,7 @@ export async function loadWallet<W extends WalletOption>(walletOption: W): Promi
     .with(WalletOption.POLKADOT_JS, async () => (await import("./polkadotjs")).polkadotWallet)
     .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
     .with(WalletOption.TALISMAN, async () => (await import("./talisman")).talismanWallet)
+    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
     .exhaustive();
 
   return wallet as SKWallets[W];

package/src/walletconnect/constants.ts

@@ -15,14 +15,17 @@ export const POLYGON_MAINNET_ID = "eip155:137";
 export const BASE_MAINNET_ID = "eip155:8453";
 export const NEAR_MAINNET_ID = "near:mainnet";
 export const NEAR_TESTNET_ID = "near:testnet";
+export const TRON_MAINNET_ID = "tron:0x2b6653dc";
 
 export const DEFAULT_LOGGER = "debug";
 
 export const DEFAULT_APP_METADATA: ClientMetadata = {
-  name: "THORSwap",
-  description: "THORSwap multi-chain dex aggregator powered by THORChain",
-  url: "https://app.thorswap.finance/",
-  icons: ["https://static.thorswap.net/logo.png"],
+  name: "SwapKit",
+  description: "SwapKit cross-chain SDK",
+  url: "https://swapkit.dev/",
+  icons: [
+    "https://raw.githubusercontent.com/swapkit/SwapKit/refs/heads/develop/docs/src/assets/logo-black.png",
+  ],
 };
 
 /**
@@ -85,3 +88,15 @@ export enum DEFAULT_NEAR_METHODS {
 }
 
 export enum DEFAULT_NEAR_EVENTS {}
+
+/**
+ * TRON
+ */
+export enum DEFAULT_TRON_METHODS {
+  TRON_SIGN_MESSAGE = "tron_signMessage",
+  TRON_SIGN_TRANSACTION = "tron_signTransaction",
+  TRON_SEND_TRANSACTION = "tron_sendTransaction",
+  TRON_GET_ACCOUNTS = "tron_getAccounts",
+}
+
+export enum DEFAULT_TRON_EVENTS {}