@lifi/sdk-provider-tron 4.0.0-alpha.21

package/dist/types/errors/parseTronErrors.d.ts

@@ -0,0 +1,3 @@
+import { type ExecutionAction, type LiFiStep, SDKError } from '@lifi/sdk';
+export declare const parseTronErrors: (e: Error, step?: LiFiStep, action?: ExecutionAction) => Promise<SDKError>;
+//# sourceMappingURL=parseTronErrors.d.ts.map

package/dist/types/errors/parseTronErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTronErrors.d.ts","sourceRoot":"","sources":["../../../src/errors/parseTronErrors.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACb,QAAQ,EAGT,MAAM,WAAW,CAAA;AASlB,eAAO,MAAM,eAAe,GAC1B,GAAG,KAAK,EACR,OAAO,QAAQ,EACf,SAAS,eAAe,KACvB,OAAO,CAAC,QAAQ,CAUlB,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { TronProvider } from './TronProvider.js';
+export type { TronProviderOptions, TronSDKProvider } from './types.js';
+export { isTronProvider } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA"}

package/dist/types/types.d.ts

@@ -0,0 +1,21 @@
+import { type LiFiStepExtended, type SDKProvider, type StepExecutorContext, type StepExecutorOptions } from '@lifi/sdk';
+import type { Adapter } from '@tronweb3/tronwallet-abstract-adapter';
+import type { SignedTransaction } from 'tronweb/lib/esm/types/Transaction';
+export interface TronProviderOptions {
+    getWallet?: () => Promise<Adapter>;
+}
+export interface TronTaskContext {
+    signedTransaction?: SignedTransaction;
+}
+export interface TronStepExecutorContext extends StepExecutorContext, TronTaskContext {
+    wallet: Adapter;
+    checkWallet: (step: LiFiStepExtended) => void;
+}
+export interface TronSDKProvider extends SDKProvider {
+    setOptions(options: TronProviderOptions): void;
+}
+export declare function isTronProvider(provider: SDKProvider): provider is TronSDKProvider;
+export interface TronStepExecutorOptions extends StepExecutorOptions {
+    wallet: Adapter;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAA;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAE1E,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;CACtC;AAED,MAAM,WAAW,uBACf,SAAQ,mBAAmB,EACzB,eAAe;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,WAAW,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAA;CAC9C;AAED,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;CAC/C;AAED,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,WAAW,GACpB,QAAQ,IAAI,eAAe,CAE7B;AAED,MAAM,WAAW,uBAAwB,SAAQ,mBAAmB;IAClE,MAAM,EAAE,OAAO,CAAA;CAChB"}

package/dist/types/version.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "@lifi/sdk-provider-tron";
+export declare const version = "4.0.0-alpha.21";
+//# sourceMappingURL=version.d.ts.map

package/dist/types/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,4BAA4B,CAAA;AAC7C,eAAO,MAAM,OAAO,mBAAmB,CAAA"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@lifi/sdk-provider-tron",
+  "version": "4.0.0-alpha.21",
+  "description": "LI.FI Tron SDK Provider for Any-to-Any Cross-Chain-Swap",
+  "homepage": "https://github.com/lifinance/sdk",
+  "bugs": {
+    "url": "https://github.com/lifinance/sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lifinance/sdk.git",
+    "directory": "packages/sdk-provider-tron"
+  },
+  "license": "Apache-2.0",
+  "author": "Eugene Chybisov <eugene@li.finance>",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "typings": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@tronweb3/tronwallet-abstract-adapter": "^1.1.10",
+    "tronweb": "^6.0.4",
+    "@lifi/sdk": "4.0.0-alpha.21"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/**",
+    "!dist/**/*.tsbuildinfo",
+    "src/**/*.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.mock.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.handlers.ts",
+    "!src/**/*.tsbuildinfo",
+    "!**/__mocks__/**",
+    "!*.tmp",
+    "!*.env",
+    "!tsconfig.json"
+  ],
+  "keywords": [
+    "swap",
+    "bridge",
+    "bridge-aggregation",
+    "cross-chain",
+    "cross-chain-applications",
+    "cross-chain-bridge",
+    "dapp",
+    "defi",
+    "ethereum",
+    "bitcoin",
+    "solana",
+    "sui",
+    "tron",
+    "lifi",
+    "multi-chain",
+    "sdk",
+    "ethers",
+    "viem",
+    "wagmi",
+    "web3",
+    "web3-react"
+  ]
+}

package/src/TronProvider.ts

@@ -0,0 +1,48 @@
+import {
+  ChainType,
+  LiFiErrorCode,
+  ProviderError,
+  type StepExecutorOptions,
+} from '@lifi/sdk'
+import { TronWeb } from 'tronweb'
+import { getTronBalance } from './actions/getTronBalance.js'
+import { resolveTronAddress } from './actions/resolveTronAddress.js'
+import { TronStepExecutor } from './core/TronStepExecutor.js'
+import type { TronProviderOptions, TronSDKProvider } from './types.js'
+
+export function TronProvider(options?: TronProviderOptions): TronSDKProvider {
+  const _options: TronProviderOptions = options ?? {}
+  return {
+    get type() {
+      return ChainType.TVM
+    },
+    isAddress: (address: string) => TronWeb.isAddress(address),
+    resolveAddress: resolveTronAddress,
+    getBalance: getTronBalance,
+    async getStepExecutor(
+      options: StepExecutorOptions
+    ): Promise<TronStepExecutor> {
+      if (!_options.getWallet) {
+        throw new ProviderError(
+          LiFiErrorCode.ProviderUnavailable,
+          'TronProvider requires a getWallet function.'
+        )
+      }
+
+      const wallet = await _options.getWallet()
+
+      const executor = new TronStepExecutor({
+        wallet,
+        routeId: options.routeId,
+        executionOptions: {
+          ...options.executionOptions,
+        },
+      })
+
+      return executor
+    },
+    setOptions(options: TronProviderOptions) {
+      Object.assign(_options, options)
+    },
+  }
+}

package/src/actions/getTronBalance.ts

@@ -0,0 +1,108 @@
+import type { SDKClient, Token, TokenAmount } from '@lifi/sdk'
+import { withDedupe } from '@lifi/sdk'
+import { TronWeb } from 'tronweb'
+
+export const getTronBalance = async (
+  client: SDKClient,
+  walletAddress: string,
+  tokens: Token[]
+): Promise<TokenAmount[]> => {
+  if (tokens.length === 0) {
+    return []
+  }
+  const { chainId } = tokens[0]
+  for (const token of tokens) {
+    if (token.chainId !== chainId) {
+      console.warn('Requested tokens have to be on the same chain.')
+    }
+  }
+
+  return getTronBalanceDefault(client, tokens, walletAddress)
+}
+
+const getTronBalanceDefault = async (
+  client: SDKClient,
+  tokens: Token[],
+  walletAddress: string
+): Promise<TokenAmount[]> => {
+  const rpcUrls = await client.getRpcUrlsByChainId(tokens[0].chainId)
+  const fullHost = rpcUrls[0] || 'https://api.trongrid.io'
+
+  const tronWeb = new TronWeb({ fullHost })
+
+  const [trxBalance, currentBlock] = await Promise.allSettled([
+    withDedupe(() => tronWeb.trx.getBalance(walletAddress), {
+      id: `${getTronBalanceDefault.name}.getBalance`,
+    }),
+    withDedupe(() => tronWeb.trx.getCurrentBlock(), {
+      id: `${getTronBalanceDefault.name}.getCurrentBlock`,
+    }),
+  ])
+
+  const nativeBalance =
+    trxBalance.status === 'fulfilled' ? BigInt(trxBalance.value) : 0n
+  const blockNumber =
+    currentBlock.status === 'fulfilled'
+      ? BigInt(currentBlock.value.block_header?.raw_data?.number ?? 0)
+      : 0n
+
+  const walletTokenAmounts: Record<string, bigint> = {}
+
+  // Identify native TRX tokens by checking for the zero address pattern
+  const nativeTokens = tokens.filter(
+    (token) =>
+      token.address === 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb' ||
+      token.address === '0x0000000000000000000000000000000000000000'
+  )
+  const trc20Tokens = tokens.filter(
+    (token) =>
+      token.address !== 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb' &&
+      token.address !== '0x0000000000000000000000000000000000000000'
+  )
+
+  for (const token of nativeTokens) {
+    walletTokenAmounts[token.address] = nativeBalance
+  }
+
+  if (trc20Tokens.length > 0) {
+    const trc20Balances = await Promise.allSettled(
+      trc20Tokens.map((token) =>
+        withDedupe(
+          async () => {
+            const contract = await tronWeb.contract().at(token.address)
+            const balance = await contract.balanceOf(walletAddress).call()
+            return {
+              address: token.address,
+              balance: BigInt(balance.toString()),
+            }
+          },
+          {
+            id: `${getTronBalanceDefault.name}.balanceOf.${token.address}`,
+          }
+        )
+      )
+    )
+
+    for (const result of trc20Balances) {
+      if (result.status === 'fulfilled' && result.value.balance > 0n) {
+        walletTokenAmounts[result.value.address] = result.value.balance
+      }
+    }
+  }
+
+  const tokenAmounts: TokenAmount[] = tokens.map((token) => {
+    if (walletTokenAmounts[token.address]) {
+      return {
+        ...token,
+        amount: walletTokenAmounts[token.address],
+        blockNumber,
+      }
+    }
+    return {
+      ...token,
+      blockNumber,
+    }
+  })
+
+  return tokenAmounts
+}

package/src/actions/resolveTronAddress.ts

@@ -0,0 +1,6 @@
+export async function resolveTronAddress(
+  _name: string
+): Promise<string | undefined> {
+  // Tron does not have a widely-adopted name service
+  return undefined
+}

package/src/core/TronStepExecutor.ts

@@ -0,0 +1,88 @@
+import {
+  BaseStepExecutor,
+  CheckBalanceTask,
+  type ExecutionAction,
+  LiFiErrorCode,
+  type LiFiStepExtended,
+  PrepareTransactionTask,
+  type SDKError,
+  type StepExecutorBaseContext,
+  TaskPipeline,
+  TransactionError,
+  WaitForTransactionStatusTask,
+} from '@lifi/sdk'
+import type { Adapter } from '@tronweb3/tronwallet-abstract-adapter'
+import { parseTronErrors } from '../errors/parseTronErrors.js'
+import type {
+  TronStepExecutorContext,
+  TronStepExecutorOptions,
+} from '../types.js'
+import { TronSignAndExecuteTask } from './tasks/TronSignAndExecuteTask.js'
+import { TronWaitForTransactionTask } from './tasks/TronWaitForTransactionTask.js'
+
+export class TronStepExecutor extends BaseStepExecutor {
+  private wallet: Adapter
+
+  constructor(options: TronStepExecutorOptions) {
+    super(options)
+    this.wallet = options.wallet
+  }
+
+  checkWallet = (step: LiFiStepExtended) => {
+    const address = this.wallet.address
+    if (address && address !== step.action.fromAddress) {
+      throw new TransactionError(
+        LiFiErrorCode.WalletChangedDuringExecution,
+        'The wallet address that requested the quote does not match the wallet address attempting to sign the transaction.'
+      )
+    }
+  }
+
+  override parseErrors = (
+    error: Error,
+    step?: LiFiStepExtended,
+    action?: ExecutionAction
+  ): Promise<SDKError> => parseTronErrors(error, step, action)
+
+  override createContext = async (
+    baseContext: StepExecutorBaseContext
+  ): Promise<TronStepExecutorContext> => {
+    return {
+      ...baseContext,
+      wallet: this.wallet,
+      checkWallet: this.checkWallet,
+    }
+  }
+
+  override createPipeline = (context: TronStepExecutorContext) => {
+    const { step, isBridgeExecution } = context
+
+    const tasks = [
+      new CheckBalanceTask(),
+      new PrepareTransactionTask(),
+      new TronSignAndExecuteTask(),
+      new TronWaitForTransactionTask(),
+      new WaitForTransactionStatusTask(
+        isBridgeExecution ? 'RECEIVING_CHAIN' : 'SWAP'
+      ),
+    ]
+
+    const swapOrBridgeAction = this.statusManager.findAction(
+      step,
+      isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+    )
+
+    const taskName =
+      swapOrBridgeAction?.txHash && swapOrBridgeAction?.status === 'DONE'
+        ? WaitForTransactionStatusTask.name
+        : CheckBalanceTask.name
+
+    const firstTaskIndex = tasks.findIndex(
+      (task) => task.constructor.name === taskName
+    )
+
+    const tasksToRun = tasks.slice(firstTaskIndex)
+
+    return new TaskPipeline(tasksToRun)
+  }
+}

package/src/core/tasks/TronSignAndExecuteTask.ts

@@ -0,0 +1,53 @@
+import {
+  BaseStepExecutionTask,
+  getTransactionRequestData,
+  LiFiErrorCode,
+  type TaskResult,
+  TransactionError,
+} from '@lifi/sdk'
+import type { TronStepExecutorContext } from '../../types.js'
+
+export class TronSignAndExecuteTask extends BaseStepExecutionTask {
+  async run(context: TronStepExecutorContext): Promise<TaskResult> {
+    const {
+      step,
+      wallet,
+      statusManager,
+      executionOptions,
+      isBridgeExecution,
+      checkWallet,
+    } = context
+
+    const action = statusManager.findAction(
+      step,
+      isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+    )
+
+    if (!action) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        'Unable to prepare transaction. Action not found.'
+      )
+    }
+
+    const transactionRequestData = await getTransactionRequestData(
+      step,
+      executionOptions
+    )
+
+    checkWallet(step)
+
+    const unsignedTransaction = JSON.parse(transactionRequestData)
+
+    const signedTransaction = await wallet.signTransaction(unsignedTransaction)
+
+    statusManager.updateAction(step, action.type, 'PENDING', {
+      signedAt: Date.now(),
+    })
+
+    return {
+      status: 'COMPLETED',
+      context: { signedTransaction },
+    }
+  }
+}

package/src/core/tasks/TronWaitForTransactionTask.ts

@@ -0,0 +1,102 @@
+import {
+  BaseStepExecutionTask,
+  LiFiErrorCode,
+  type TaskResult,
+  TransactionError,
+} from '@lifi/sdk'
+import { TronWeb } from 'tronweb'
+import type { TronStepExecutorContext } from '../../types.js'
+
+export class TronWaitForTransactionTask extends BaseStepExecutionTask {
+  async run(context: TronStepExecutorContext): Promise<TaskResult> {
+    const {
+      client,
+      step,
+      statusManager,
+      fromChain,
+      isBridgeExecution,
+      signedTransaction,
+    } = context
+
+    if (!signedTransaction) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        'Unable to prepare transaction. Signed transaction is not found.'
+      )
+    }
+
+    const action = statusManager.findAction(
+      step,
+      isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+    )
+    if (!action) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        'Unable to prepare transaction. Action not found.'
+      )
+    }
+
+    const rpcUrls = await client.getRpcUrlsByChainId(fromChain.id)
+    const fullHost = rpcUrls[0] || 'https://api.trongrid.io'
+    const tronWeb = new TronWeb({ fullHost })
+
+    const broadcastResult =
+      await tronWeb.trx.sendRawTransaction(signedTransaction)
+
+    if (!broadcastResult.result) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionFailed,
+        `Transaction broadcast failed: ${(broadcastResult as any).code || 'Unknown error'}`
+      )
+    }
+
+    const txHash = broadcastResult.transaction.txID
+
+    statusManager.updateAction(step, action.type, 'PENDING', {
+      txHash,
+      txLink: `${fromChain.metamask.blockExplorerUrls[0]}#/transaction/${txHash}`,
+    })
+
+    await waitForTronConfirmation(tronWeb, txHash)
+
+    if (isBridgeExecution) {
+      statusManager.updateAction(step, action.type, 'DONE')
+    }
+
+    return { status: 'COMPLETED' }
+  }
+}
+
+async function waitForTronConfirmation(
+  tronWeb: TronWeb,
+  txHash: string,
+  maxRetries = 20,
+  intervalMs = 3000
+): Promise<void> {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const txInfo = await tronWeb.trx.getTransactionInfo(txHash)
+
+      if (txInfo?.id) {
+        if (txInfo.receipt?.result === 'FAILED') {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            `Transaction failed on-chain: ${txInfo.receipt.result}`
+          )
+        }
+        return
+      }
+    } catch (error) {
+      if (error instanceof TransactionError) {
+        throw error
+      }
+      // Transaction info not yet available, continue polling
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+
+  throw new TransactionError(
+    LiFiErrorCode.TransactionFailed,
+    'Transaction confirmation timeout.'
+  )
+}

package/src/errors/parseTronErrors.ts

@@ -0,0 +1,83 @@
+import {
+  BaseError,
+  ErrorMessage,
+  type ExecutionAction,
+  LiFiErrorCode,
+  type LiFiStep,
+  SDKError,
+  TransactionError,
+  UnknownError,
+} from '@lifi/sdk'
+import {
+  WalletDisconnectedError,
+  WalletNotFoundError,
+  WalletNotSelectedError,
+  WalletSignTransactionError,
+  WalletWindowClosedError,
+} from '@tronweb3/tronwallet-abstract-adapter'
+
+export const parseTronErrors = async (
+  e: Error,
+  step?: LiFiStep,
+  action?: ExecutionAction
+): Promise<SDKError> => {
+  if (e instanceof SDKError) {
+    e.step = e.step ?? step
+    e.action = e.action ?? action
+    return e
+  }
+
+  const baseError = handleSpecificErrors(e)
+
+  return new SDKError(baseError, step, action)
+}
+
+const handleSpecificErrors = (e: any) => {
+  const message: string = typeof e === 'string' ? e : e.message || ''
+
+  if (
+    e instanceof WalletSignTransactionError ||
+    e instanceof WalletWindowClosedError
+  ) {
+    return new TransactionError(LiFiErrorCode.SignatureRejected, message, e)
+  }
+
+  if (
+    e instanceof WalletNotFoundError ||
+    e instanceof WalletNotSelectedError ||
+    e instanceof WalletDisconnectedError
+  ) {
+    return new TransactionError(
+      LiFiErrorCode.WalletChangedDuringExecution,
+      message,
+      e
+    )
+  }
+
+  // TronWeb trx.sign() validation errors
+  if (
+    message === 'Invalid transaction provided' ||
+    message === 'Invalid transaction' ||
+    message === 'Transaction is not signed'
+  ) {
+    return new TransactionError(LiFiErrorCode.TransactionUnprepared, message, e)
+  }
+
+  if (message === 'Transaction is already signed') {
+    return new TransactionError(LiFiErrorCode.TransactionFailed, message, e)
+  }
+
+  if (message === 'Private key does not match address in transaction') {
+    return new TransactionError(
+      LiFiErrorCode.WalletChangedDuringExecution,
+      message,
+      e
+    )
+  }
+
+  if (e instanceof BaseError) {
+    return e
+  }
+
+  return new UnknownError(message || ErrorMessage.UnknownError, e)
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+// biome-ignore lint/performance/noBarrelFile: module entrypoint
+export { TronProvider } from './TronProvider.js'
+export type { TronProviderOptions, TronSDKProvider } from './types.js'
+export { isTronProvider } from './types.js'

package/src/types.ts

@@ -0,0 +1,38 @@
+import {
+  ChainType,
+  type LiFiStepExtended,
+  type SDKProvider,
+  type StepExecutorContext,
+  type StepExecutorOptions,
+} from '@lifi/sdk'
+import type { Adapter } from '@tronweb3/tronwallet-abstract-adapter'
+import type { SignedTransaction } from 'tronweb/lib/esm/types/Transaction'
+
+export interface TronProviderOptions {
+  getWallet?: () => Promise<Adapter>
+}
+
+export interface TronTaskContext {
+  signedTransaction?: SignedTransaction
+}
+
+export interface TronStepExecutorContext
+  extends StepExecutorContext,
+    TronTaskContext {
+  wallet: Adapter
+  checkWallet: (step: LiFiStepExtended) => void
+}
+
+export interface TronSDKProvider extends SDKProvider {
+  setOptions(options: TronProviderOptions): void
+}
+
+export function isTronProvider(
+  provider: SDKProvider
+): provider is TronSDKProvider {
+  return provider.type === ChainType.TVM
+}
+
+export interface TronStepExecutorOptions extends StepExecutorOptions {
+  wallet: Adapter
+}

package/src/version.ts

@@ -0,0 +1,2 @@
+export const name = '@lifi/sdk-provider-tron'
+export const version = '4.0.0-alpha.21'