Connector for tronlink, or Tron Network

[Monahawk]

Hello all,

I am about to try to create a tron network connector, but I am not certain which should be the correct way to start.

In tron there is no Signer I guess, you need to work with tronweb itself.

[Chi111]

hi，I have the same confusion as you, do you have a solution now?

[HenryTeyk]

Did you succeed? if yes then write more

[lukoyanov]

Also interested in connector for Tron.

[msilucifer]

No idea for integrating Tron network with wagmi?

[Canazo]

What ever happened with this? I'm in the same boat. I need a way to integrate wagmi and Tron network.

[tmm]

You are in luck! There is a guide on Creating Connectors.

[msilucifer]

I can't find the solution in the above guideline.

[Canazo]

There are no connectors for Tron network in Wagmi. Ethereum network only.

[RedWilly]

i have a simple test.
and not tested ( there is no connector to tron yet but i think these might be a stepping stone.

// packages/connector/src/tron.ts

import { createConnector } from '@wagmi/core'
import type { Chain, ProviderMessage } from '@wagmi/core'
import type { Address } from 'viem'


import {
  getTronProvider,
  getTronAccounts,
  switchTronChain,
  getTronChainId,
  addTronChain,
} from './tronUtils' 

export const TRON_MAINNET_CHAIN_ID = 728061916

export type TronParameters = {
  chains?: Chain[]
  shimDisconnect?: boolean
}

type TronProvider = {
  request: (args: { method: string; params?: any[] }) => Promise<any>
  on: (event: string, callback: (payload: any) => void) => void
  removeListener: (event: string, callback: (payload: any) => void) => void
}

export function tron({
  chains = [],
  shimDisconnect = false,
}: TronParameters = {}) {
  return createConnector<TronProvider, TronParameters>((config) => ({
    id: 'tron',
    name: 'Tron',
    type: 'tron',
    icon: 'https://tronscan.org/static/media/TRON.39b98c05.svg',

    async connect({ chainId } = {}) {
      const provider = await getTronProvider()
      const accounts = await getTronAccounts(provider)
      const currentChainId = await this.getChainId()

      if (chainId && currentChainId !== chainId) {
        await this.switchChain({ chainId })
      }

      return { accounts, chainId: await this.getChainId() }
    },

    async disconnect() {
      const provider = await getTronProvider()
      if (!provider?.removeListener) return

      provider.removeListener('accountsChanged', this.onAccountsChanged)
      provider.removeListener('chainChanged', this.onChainChanged)
      provider.removeListener('disconnect', this.onDisconnect)
    },

    async getAccounts() {
      const provider = await getTronProvider()
      return getTronAccounts(provider)
    },

    async getChainId() {
      const provider = await getTronProvider()
      return getTronChainId(provider)
    },

    async getProvider() {
      return getTronProvider()
    },

    async isAuthorized() {
      try {
        const provider = await getTronProvider()
        const accounts = await getTronAccounts(provider)
        return !!accounts.length
      } catch {
        return false
      }
    },

    async switchChain({ chainId }) {
      const provider = await getTronProvider()
      const currentChainId = await this.getChainId()
      if (currentChainId === chainId) return

      try {
        await switchTronChain(provider, chainId)
        return chains.find((x) => x.id === chainId) ?? {
          id: chainId,
          name: chainId === TRON_MAINNET_CHAIN_ID ? 'Tron Mainnet' : `Tron Chain ${chainId}`,
          network: chainId === TRON_MAINNET_CHAIN_ID ? 'mainnet' : `${chainId}`,
          nativeCurrency: { name: 'TRX', decimals: 6, symbol: 'TRX' },
          rpcUrls: { 
            default: { http: ['https://api.trongrid.io'] },
            public: { http: ['https://api.trongrid.io'] }
          },
        }
      } catch (error) {
        // Note: Tron is a different thing all together so adjust if need, 
        if ((error as any).code === 4902) {
          try {
            await addTronChain(provider, { chainId })
            return chains.find((x) => x.id === chainId) ?? {
              id: chainId,
              name: chainId === TRON_MAINNET_CHAIN_ID ? 'Tron Mainnet' : `Tron Chain ${chainId}`,
              network: chainId === TRON_MAINNET_CHAIN_ID ? 'mainnet' : `${chainId}`,
              nativeCurrency: { name: 'TRX', decimals: 6, symbol: 'TRX' },
              rpcUrls: { 
                default: { http: ['https://api.trongrid.io'] },
                public: { http: ['https://api.trongrid.io'] }
              },
            }
          } catch (addError) {
            throw addError
          }
        }
        throw error
      }
    },

    onAccountsChanged(accounts: Address[]) {
      config.emitter.emit('change', { accounts: accounts.map((x) => x.toLowerCase()) })
    },

    onChainChanged(chainId: number) {
      config.emitter.emit('change', { chainId })
    },

    onDisconnect(error: Error) {
      config.emitter.emit('disconnect')
      if (error) config.emitter.emit('error', error)
    },

    onMessage({ type, data }: ProviderMessage) {
      config.emitter.emit('message', { type, data })
    },
  }))
}

okay for my example - tronUtils
// tronUtils.ts

import { getAddress } from 'viem'

interface TronProvider {
  request: (args: { method: string; params?: any[] }) => Promise<any>
  on: (event: string, callback: (payload: any) => void) => void
  removeListener: (event: string, callback: (payload: any) => void) => void
}

// adjust this based on how the Tron wallet is injected - again not tested only concerpt
declare global {
  interface Window {
    tronWeb?: TronProvider
  }
}

export async function getTronProvider(): Promise<TronProvider> {
  if (typeof window === 'undefined') throw new Error('Window is undefined')
  if (!window.tronWeb) throw new Error('Tron provider not found')
  
  return window.tronWeb
}

export async function getTronAccounts(provider: TronProvider): Promise<string[]> {
  try {
    const accounts = await provider.request({ method: 'eth_accounts' })
    return accounts.map((account: string) => getAddress(account))
  } catch (error) {
    console.error('Failed to get Tron accounts', error)
    return []
  }
}

export async function switchTronChain(provider: TronProvider, chainId: number): Promise<void> {
  try {
    await provider.request({
      method: 'wallet_switchEthereumChain',
      params: [{ chainId: `0x${chainId.toString(16)}` }],
    })
  } catch (error: any) {
    if (error.code === 4902) {
      throw new Error('This chain is not added to the wallet')
    }
    throw error
  }
}

export async function getTronChainId(provider: TronProvider): Promise<number> {
  try {
    const chainIdHex = await provider.request({ method: 'eth_chainId' })
    return parseInt(chainIdHex, 16)
  } catch (error) {
    console.error('Failed to get Tron chain ID', error)
    throw error
  }
}

export async function addTronChain(provider: TronProvider, { chainId }: { chainId: number }): Promise<void> {
  // Note:  So again adjust his or remove entirely and have it switch / pop up tronlink or other extension/apps. 
//just following guidelines
  try {
    await provider.request({
      method: 'wallet_addEthereumChain',
      params: [
        {
          chainId: `0x${chainId.toString(16)}`,
          chainName: `Tron Chain ${chainId}`,
          nativeCurrency: {
            name: 'TRX',
            symbol: 'TRX',
            decimals: 6,
          },
          rpcUrls: ['https://api.trongrid.io'],
          blockExplorerUrls: ['https://tronscan.org'],
        },
      ],
    })
  } catch (error) {
    console.error('Failed to add Tron chain', error)
    throw error
  }
}

export function isTronChain(chainId: number): boolean {
  const knownTronChainIds = [728061916] 
  return knownTronChainIds.includes(chainId)
}

[salemalem]

Just use tronweb

[msilucifer]

For instance, how can you handle OKX wallet?
OKX wallet provides both Tron Ethereum networks.
In this case, when you connect to Tron network using OKX wallet, you need to use tronweb. And also when yo connect to other network again, yo need to convert wagmi. Are the two modules compatible with each other?