@layerzerolabs/lz-corekit-tron 3.0.14 → 3.0.16

package/dist/index.cjs

@@ -1,18 +1,26 @@
 'use strict';
 
 var ethers = require('ethers');
-var mem = require('mem');
 var TronWeb5 = require('tronweb');
 var lzCore = require('@layerzerolabs/lz-core');
-var tronUtilities = require('@layerzerolabs/tron-utilities');
 var lzUtilities = require('@layerzerolabs/lz-utilities');
+var tronUtilities = require('@layerzerolabs/tron-utilities');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var mem__default = /*#__PURE__*/_interopDefault(mem);
 var TronWeb5__default = /*#__PURE__*/_interopDefault(TronWeb5);
 
-// src/providers/tron.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
 function ensureJsonRpcUrlPostfix(url) {
   const value = url.trim().replace(/\/*$/, "");
   if (!value.endsWith("/jsonrpc")) {
@@ -39,37 +47,13 @@ function toValidHash(txHash) {
 // src/providers/tron.ts
 var TronProvider = class {
   /**
+   * Creates an instance of TronProvider.
    *
-   * @param url RPC endpoint of the Tron full node, e.g. 'https://api.trongrid.io'
-   * @param apiKey
+   * @param {string} url - RPC endpoint of the Tron full node, e.g. 'https://api.trongrid.io'
+   * @param {string} [apiKey] - The API key for accessing the Tron full node (optional).
    */
   constructor(url, apiKey) {
     this.url = url;
-    this.buildTronWebFrom = mem__default.default(
-      (provider) => {
-        if (provider instanceof ethers.ethers.providers.JsonRpcProvider) {
-          const { url } = provider.connection;
-          const apiKey = provider.connection.headers?.["TRON-PRO-API-KEY"];
-          return new TronWeb5__default.default({
-            privateKey: void 0,
-            fullHost: tronUtilities.StrategyFactory.get(url).asREST(url),
-            headers: { ...apiKey !== void 0 ? { "TRON-PRO-API-KEY": apiKey } : {} }
-          });
-        }
-        throw new Error(`The nativeSigner is not supported.`);
-      },
-      {
-        cacheKey: (arguments_) => {
-          const provider = arguments_[0];
-          if (provider instanceof ethers.ethers.providers.JsonRpcProvider) {
-            const { url } = provider.connection;
-            const apiKey = provider.connection.headers?.["TRON-PRO-API-KEY"];
-            return JSON.stringify({ url, apiKey });
-          }
-          return JSON.stringify(provider);
-        }
-      }
-    );
     this.nativeProvider = new ethers.ethers.providers.StaticJsonRpcProvider({
       url: tronUtilities.StrategyFactory.get(url).asJSONRPC(url),
       headers: {
@@ -78,6 +62,14 @@ var TronProvider = class {
       }
     });
   }
+  /**
+   * Creates an instance of TronProvider from the given source.
+   *
+   * @param {string | TronWeb} source - The source to create the provider from.
+   * @param {string} [apiKey] - The API key for accessing the Tron node (optional).
+   * @returns {TronProvider} The created TronProvider instance.
+   * @throws {Error} If the parameters are invalid.
+   */
   static from(source, apiKey) {
     if (typeof source === "string") {
       return new this(source, apiKey);
@@ -89,65 +81,170 @@ var TronProvider = class {
     }
   }
   /**
-   * Returns the native provider
+   * Returns the native provider.
+   *
+   * @returns {unknown} The native provider.
    */
   get native() {
     return this.nativeProvider;
   }
+  buildTronWebFrom(provider) {
+    if (provider instanceof ethers.ethers.providers.JsonRpcProvider) {
+      const { url } = provider.connection;
+      const apiKey = provider.connection.headers?.["TRON-PRO-API-KEY"];
+      return new TronWeb5__default.default({
+        privateKey: void 0,
+        fullHost: tronUtilities.StrategyFactory.get(url).asREST(url),
+        headers: { ...apiKey !== void 0 ? { "TRON-PRO-API-KEY": apiKey } : {} }
+      });
+    }
+    throw new Error(`The nativeSigner is not supported.`);
+  }
+  /**
+   * Gets the balance of the specified address.
+   *
+   * @param {string} address - The address to get the balance of.
+   * @returns {Promise<string>} A promise that resolves to the balance of the address.
+   */
   async getBalance(address) {
     return this.nativeProvider.getBalance(toEtherFormat(address)).then((balance) => balance.toString());
   }
+  /**
+   * Gets the block specified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<Block>} A promise that resolves to the block.
+   */
   async getBlock(blockTag) {
     const response = await this.nativeProvider.getBlock(blockTag);
     return lzCore.Block.from(response);
   }
+  /**
+   * Gets the block with transactions specified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<BlockWithTransactions>} A promise that resolves to the block with transactions.
+   */
   async getBlockWithTransactions(blockTag) {
     const response = await this.nativeProvider.getBlockWithTransactions(blockTag);
     return lzCore.BlockWithTransactions.from(response);
   }
+  /**
+   * Gets the current block number.
+   *
+   * @returns {Promise<number>} A promise that resolves to the current block number.
+   */
   async getBlockNumber() {
     return this.nativeProvider.getBlockNumber();
   }
+  /**
+   * Gets the UNIX timestamp for the block identified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<number>} A promise that resolves to the UNIX timestamp of the block.
+   */
   async getBlockTimestamp(blockTag) {
     return this.nativeProvider.getBlock(blockTag).then((block) => block.timestamp);
   }
+  /**
+   * Gets the current slot number for commitment, not suitable for Tron.
+   *
+   * @param {Finality} [finality] - The commitment level (optional).
+   * @returns {Promise<number>} A promise that resolves to the current slot number.
+   * @throws {Error} Method not implemented.
+   */
   async getSlot(_finality) {
     await Promise.resolve();
     throw new Error("Method not implemented.");
   }
+  /**
+   * Gets information about a transaction.
+   *
+   * @param {string} txHash - The hash of the transaction.
+   * @returns {Promise<TransactionResponse>} A promise that resolves to the transaction response.
+   */
   async getTransaction(txHash) {
     const response = await this.nativeProvider.getTransaction(toValidHash(txHash));
     return lzCore.TransactionResponse.from(response);
   }
+  /**
+   * Gets the receipt of a transaction.
+   *
+   * @param {string} txHash - The hash of the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async getTransactionReceipt(txHash) {
     const response = await this.nativeProvider.getTransactionReceipt(toValidHash(txHash));
     return lzCore.TransactionReceipt.from(response);
   }
+  /**
+   * Gets the number of transactions sent from the specified address.
+   *
+   * @param {string | Promise<string>} _addressOrName - The address to get the number of transactions from.
+   * @param {BlockTag | Promise<BlockTag>} [_blockTag] - The block tag to get the number of transactions from (optional).
+   * @returns {Promise<number>} A promise that resolves to the number of transactions sent from the address.
+   * @throws {Error} Method not supported in Tron.
+   */
   async getTransactionCount(_addressOrName, _blockTag) {
     await Promise.resolve();
     throw new Error("Method not supported in Tron.");
   }
+  /**
+   * Sends a signed transaction to the blockchain.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, _sendOptions) {
     const stx = transaction.signed;
     const client = this.buildTronWebFrom(this.nativeProvider);
     const response = await tronUtilities.sendTronTransaction(stx, client);
     return lzCore.TransactionPending.from(response);
   }
+  /**
+   * Confirms a pending transaction.
+   *
+   * @param {TransactionPending} pending - The pending transaction to confirm.
+   * @param {object} [opts] - Optional parameters for the confirmation.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async confirmTransaction(pending, _opts) {
     const nativePending = pending.pending;
     const response = await nativePending.wait();
     return lzCore.TransactionReceipt.from(response);
   }
+  /**
+   * Sends a signed transaction and waits for confirmation.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [opts] - Optional parameters for sending and confirming the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async sendAndConfirm(transaction, opts) {
     const pending = await this.sendTransaction(transaction, opts);
     return this.confirmTransaction(pending, opts);
   }
 };
+__decorateClass([
+  lzUtilities.Memoizee({
+    normalizer: (args) => {
+      const provider = args[0];
+      if (provider instanceof ethers.ethers.providers.JsonRpcProvider) {
+        const { url } = provider.connection;
+        const apiKey = provider.connection.headers?.["TRON-PRO-API-KEY"];
+        return JSON.stringify({ url, apiKey });
+      }
+      return JSON.stringify(provider);
+    }
+  })
+], TronProvider.prototype, "buildTronWebFrom", 1);
 var TronWebProvider = class {
   /**
-   * Create a new TronProvider
-   * @param url RPC endpoint of the Tron full node, e.g. 'https://api.trongrid.io'
-   * @param apiKey
+   * Creates a new TronWebProvider.
+   *
+   * @param {string} url - The RPC endpoint of the Tron full node, e.g., 'https://api.trongrid.io'.
+   * @param {string} [apiKey] - The API key for accessing the Tron full node (optional).
    */
   constructor(url, apiKey) {
     this.url = url;
@@ -160,6 +257,14 @@ var TronWebProvider = class {
       }
     });
   }
+  /**
+   * Creates an instance of TronWebProvider from the given source.
+   *
+   * @param {string} source - The source to create the provider from.
+   * @param {string} [apiKey] - The API key for accessing the Tron node (optional).
+   * @returns {TronWebProvider} The created TronWebProvider instance.
+   * @throws {Error} If the parameters are invalid.
+   */
   static from(source, apiKey) {
     if (typeof source === "string") {
       return new this(source, apiKey);
@@ -167,20 +272,48 @@ var TronWebProvider = class {
       throw new Error("Invalid parameters");
     }
   }
+  /**
+   * Gets the native TronWeb provider instance.
+   *
+   * @returns {TronWeb} The native TronWeb provider instance.
+   */
   get native() {
     return this.nativeProvider;
   }
+  /**
+   * Gets the balance of the specified address.
+   *
+   * @param {string} address - The address to get the balance of.
+   * @returns {Promise<string>} A promise that resolves to the balance of the address.
+   */
   async getBalance(address) {
     return this.nativeProvider.trx.getBalance(address).then((balance) => balance.toString());
   }
+  /**
+   * Gets the block specified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<Block>} A promise that resolves to the block.
+   */
   async getBlock(blockTag) {
     const response = await this.nativeProvider.trx.getBlock(blockTag);
     return lzCore.Block.from(response);
   }
+  /**
+   * Gets the block with transactions specified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<BlockWithTransactions>} A promise that resolves to the block with transactions.
+   */
   async getBlockWithTransactions(blockTag) {
     const response = await this.nativeProvider.trx.getBlock(blockTag);
     return lzCore.BlockWithTransactions.from(response);
   }
+  /**
+   * Gets the current block number.
+   *
+   * @returns {Promise<number>} A promise that resolves to the current block number.
+   */
   async getBlockNumber() {
     return this.nativeProvider.trx.getBlock("latest").then((block) => {
       if (block.block_header.raw_data.number === void 0) {
@@ -189,6 +322,12 @@ var TronWebProvider = class {
       return block.block_header.raw_data.number;
     });
   }
+  /**
+   * Gets the UNIX timestamp for the block identified by blockTag.
+   *
+   * @param {BlockTag} blockTag - The block tag to specify the block.
+   * @returns {Promise<number>} A promise that resolves to the UNIX timestamp of the block.
+   */
   async getBlockTimestamp(blockTag) {
     return this.nativeProvider.trx.getBlock(blockTag).then((block) => {
       if (block.block_header.raw_data.timestamp === void 0) {
@@ -197,22 +336,56 @@ var TronWebProvider = class {
       return block.block_header.raw_data.timestamp;
     });
   }
+  /**
+   * Gets the current slot number for commitment, not suitable for Tron.
+   *
+   * @param {Finality} [finality] - The commitment level (optional).
+   * @returns {Promise<number>} A promise that resolves to the current slot number.
+   * @throws {Error} Method not implemented.
+   */
   async getSlot(_finality) {
     await Promise.resolve();
     throw new Error("Method not implemented.");
   }
+  /**
+   * Gets information about a transaction.
+   *
+   * @param {string} txHash - The hash of the transaction.
+   * @returns {Promise<TransactionResponse>} A promise that resolves to the transaction response.
+   */
   async getTransaction(txHash) {
     const response = await this.nativeProvider.trx.getTransaction(txHash);
     return lzCore.TransactionResponse.from(response);
   }
+  /**
+   * Gets the receipt of a transaction.
+   *
+   * @param {string} txHash - The hash of the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async getTransactionReceipt(txHash) {
     const response = await this.nativeProvider.trx.getTransactionInfo(txHash);
     return lzCore.TransactionReceipt.from(response);
   }
+  /**
+   * Gets the number of transactions sent from the specified address.
+   *
+   * @param {string | Promise<string>} _addressOrName - The address to get the number of transactions from.
+   * @param {BlockTag | Promise<BlockTag>} [_blockTag] - The block tag to get the number of transactions from (optional).
+   * @returns {Promise<number>} A promise that resolves to the number of transactions sent from the address.
+   * @throws {Error} Method not supported in Tron.
+   */
   async getTransactionCount(_addressOrName, _blockTag) {
     await Promise.resolve();
     throw new Error("Method not supported in Tron.");
   }
+  /**
+   * Sends a signed transaction to the blockchain.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, sendOptions) {
     const stx = transaction.signed;
     const response = await this.nativeProvider.trx.sendRawTransaction(stx, sendOptions);
@@ -228,6 +401,13 @@ var TronWebProvider = class {
     }
     return lzCore.TransactionPending.from(response);
   }
+  /**
+   * Confirms a pending transaction.
+   *
+   * @param {TransactionPending} pending - The pending transaction to confirm.
+   * @param {object} [opts] - Optional parameters for the confirmation.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async confirmTransaction(pending, opts) {
     const nativePending = pending.pending;
     const txHash = nativePending.txid;
@@ -259,15 +439,35 @@ var TronWebProvider = class {
     }
     throw new Error(`Transaction not confirmed, txHash: ${txHash}`);
   }
+  /**
+   * Sends a signed transaction and waits for confirmation.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [opts] - Optional parameters for sending and confirming the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async sendAndConfirm(transaction, opts) {
     const pending = await this.sendTransaction(transaction, opts);
     return this.confirmTransaction(pending, opts);
   }
 };
 var _TronSigner = class _TronSigner {
+  /**
+   * Creates an instance of TronSigner.
+   *
+   * @param {ethers.Signer} signer - The Ethers signer to use.
+   */
   constructor(signer) {
     this.nativeSigner = signer;
   }
+  /**
+   * Creates an instance of TronSigner from the given source.
+   *
+   * @param {ethers.Signer | TronWeb | string} source - The source to create the TronSigner from.
+   * @param {string} [path] - The derivation path (optional).
+   * @returns {Signer} The created TronSigner instance.
+   * @throws {Error} If the parameters are invalid.
+   */
   static from(source, path) {
     if (source instanceof ethers.ethers.Signer) {
       return new this(source);
@@ -286,9 +486,22 @@ var _TronSigner = class _TronSigner {
       throw new Error("Invalid parameters");
     }
   }
+  /**
+   * Gets the native signer instance.
+   *
+   * @returns {unknown} The native signer instance.
+   */
   get native() {
     return this.nativeSigner;
   }
+  /**
+   * Connects the signer to a provider.
+   * IMPORTANT: native provider must be an instance of ethers.providers.JsonRpcProvider.
+   *
+   * @param {Provider} provider - The provider to connect to.
+   * @returns {Signer} The connected signer.
+   * @throws {Error} If the provider is not an instance of JsonRpcProvider.
+   */
   connect(provider) {
     if (!(provider.native instanceof ethers.ethers.providers.JsonRpcProvider)) {
       throw new Error("Only JsonRpcProvider is supported.");
@@ -297,6 +510,14 @@ var _TronSigner = class _TronSigner {
     ethers.ethers.utils.defineReadOnly(this, "nativeSigner", signer);
     return this;
   }
+  /**
+   * Builds a TronWeb instance from the given signer.
+   * IMPORTANT: signer must be an instance of ethers.Wallet.
+   *
+   * @param {ethers.Signer} signer - The signer to build the TronWeb instance from.
+   * @returns {TronWeb} The built TronWeb instance.
+   * @throws {Error} If the signer is not supported.
+   */
   static buildTronWebFrom(signer) {
     if (signer instanceof ethers.ethers.Wallet) {
       if (signer.provider instanceof ethers.ethers.providers.JsonRpcProvider) {
@@ -306,15 +527,41 @@ var _TronSigner = class _TronSigner {
     }
     throw new Error(`The nativeSigner is not supported.`);
   }
+  static createTronWeb(url, privateKey, apiKey) {
+    return new TronWeb5__default.default({
+      privateKey: lzUtilities.trim0x(privateKey),
+      fullHost: removeJsonRpcUrlPostfix(url),
+      headers: { ...apiKey !== void 0 ? { "TRON-PRO-API-KEY": apiKey } : {} }
+    });
+  }
+  /**
+   * Gets the address of the signer.
+   *
+   * @returns {Promise<string>} A promise that resolves to the address of the signer.
+   */
   async getAddress() {
     return this.nativeSigner.getAddress();
   }
+  /**
+   * Sends a signed transaction and waits for confirmation.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [opts] - Optional parameters for sending and confirming the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async sendAndConfirm(transaction, _opts) {
     const pending = (await this.sendTransaction(transaction)).pending;
     await pending.wait();
     const response = await this.nativeSigner.provider?.getTransactionReceipt(toValidHash(pending.txId));
     return lzCore.TransactionReceipt.from(response);
   }
+  /**
+   * Signs a transaction.
+   *
+   * @param {TransactionRequest} transaction - The transaction request to sign.
+   * @returns {Promise<SignedTransaction>} A promise that resolves to the signed transaction.
+   * @throws {Error} If the transaction is invalid.
+   */
   async signTransaction(transaction) {
     const tx = transaction.request;
     if (tx.data === void 0 || tx.to === void 0) {
@@ -335,41 +582,76 @@ var _TronSigner = class _TronSigner {
     );
     return lzCore.SignedTransaction.from(response);
   }
+  /**
+   * Sends a signed transaction.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, _sendOptions) {
     const stx = transaction.signed;
     const tronWeb = _TronSigner.buildTronWebFrom(this.nativeSigner);
     const response = await tronUtilities.sendTronTransaction(stx, tronWeb);
     return lzCore.TransactionPending.from(response);
   }
+  /**
+   * Signs a buffer (e.g., a message hash) using the native Tron signer.
+   *
+   * @param {Uint8Array} buffer - The buffer to sign.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the signed buffer as a Uint8Array.
+   */
   async signBuffer(buffer) {
     const signedMessage = await this.nativeSigner.signMessage(buffer);
     return ethers.ethers.utils.arrayify(signedMessage);
   }
+  /**
+   * Validates a transaction.
+   *
+   * @param {ethers.PopulatedTransaction} transaction - The transaction to validate.
+   * @returns {boolean} True if the transaction is valid, false otherwise.
+   * @throws {Error} If the transaction is invalid.
+   */
   static validateTransaction(transaction) {
     if (transaction.data === void 0 || transaction.to === void 0) {
       throw new Error("Invalid transaction, missing data or to");
     }
     return true;
   }
+  /**
+   * Builds a transaction.
+   *
+   * @param {unknown} buildTxRequest - The transaction request to build.
+   * @returns {Promise<TransactionRequest>} A promise that resolves to the built transaction request.
+   * @throws {Error} Method not implemented.
+   */
   async buildTransaction(buildTxRequest) {
     return Promise.reject(new Error("Method not implemented."));
   }
 };
-_TronSigner.createTronWeb = mem__default.default(
-  (url, privateKey, apiKey) => {
-    return new TronWeb5__default.default({
-      privateKey: lzUtilities.trim0x(privateKey),
-      fullHost: removeJsonRpcUrlPostfix(url),
-      headers: { ...apiKey !== void 0 ? { "TRON-PRO-API-KEY": apiKey } : {} }
-    });
-  },
-  { cacheKey: (arguments_) => JSON.stringify(arguments_) }
-);
+__decorateClass([
+  lzUtilities.Memoizee({
+    normalizer: (args) => JSON.stringify(args)
+  })
+], _TronSigner, "createTronWeb", 1);
 var TronSigner = _TronSigner;
 var TronWebSigner = class _TronWebSigner {
+  /**
+   * Creates an instance of TronWebSigner.
+   *
+   * @param {TronWeb} signer - The TronWeb signer to use.
+   */
   constructor(signer) {
     this.nativeSigner = signer;
   }
+  /**
+   * Creates an instance of TronWebSigner from the given source.
+   *
+   * @param {TronWeb | string} source - The source to create the TronWebSigner from.
+   * @param {string} [path] - The derivation path (optional).
+   * @returns {Signer} The created TronWebSigner instance.
+   * @throws {Error} If the parameters are invalid.
+   */
   static from(source, path) {
     const fullHost = "https://api.trongrid.io";
     if (source instanceof TronWeb5__default.default) {
@@ -384,9 +666,20 @@ var TronWebSigner = class _TronWebSigner {
       throw new Error("Invalid parameters");
     }
   }
+  /**
+   * Gets the native TronWeb signer instance.
+   *
+   * @returns {unknown} The native TronWeb signer instance.
+   */
   get native() {
     return this.nativeSigner;
   }
+  /**
+   * Connects the signer to a provider.
+   *
+   * @param {Provider} provider - The provider to connect to.
+   * @returns {Signer} The connected signer.
+   */
   connect(provider) {
     const nativeProvider = provider.native;
     const { fullNode, solidityNode, eventServer } = nativeProvider.currentProviders();
@@ -395,6 +688,11 @@ var TronWebSigner = class _TronWebSigner {
     this.nativeSigner.setEventServer(eventServer);
     return this;
   }
+  /**
+   * Gets the address of the signer.
+   *
+   * @returns {Promise<string>} A promise that resolves to the address of the signer.
+   */
   async getAddress() {
     if (typeof this.nativeSigner.defaultAddress.hex !== "string") {
       throw new Error("Invalid address");
@@ -402,11 +700,25 @@ var TronWebSigner = class _TronWebSigner {
     const retval = this.nativeSigner.defaultAddress.hex.replace(/^41/, "0x");
     return Promise.resolve(retval);
   }
+  /**
+   * Sends a signed transaction and waits for confirmation.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [sendOptions] - Optional parameters for sending and confirming the transaction.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   */
   async sendAndConfirm(transaction, _sendOptions) {
     const pending = (await this.sendTransaction(transaction)).pending;
     const response = await pending.wait();
     return lzCore.TransactionReceipt.from(response);
   }
+  /**
+   * Signs a transaction.
+   *
+   * @param {TransactionRequest} transaction - The transaction request to sign.
+   * @returns {Promise<SignedTransaction>} A promise that resolves to the signed transaction.
+   * @throws {Error} If the transaction is invalid.
+   */
   async signTransaction(transaction) {
     const tx = transaction.request;
     if (tx.data === void 0 || tx.to === void 0) {
@@ -426,6 +738,13 @@ var TronWebSigner = class _TronWebSigner {
     );
     return lzCore.SignedTransaction.from(response);
   }
+  /**
+   * Sends a signed transaction.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {object} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, _sendOptions) {
     const stx = transaction.signed;
     const response = await tronUtilities.sendTronTransaction(stx, this.nativeSigner);
@@ -438,8 +757,10 @@ var TronWebSigner = class _TronWebSigner {
    * the message length is 32 bytes, the signature will be the same as the ethereum signature.
    * you can find the signString function here:
    * https://github.com/tronprotocol/tronweb/blob/master/src/lib/trx.js
-   * @param buffer
-   * @returns
+   *
+   * @param {Uint8Array} buffer - The buffer to sign.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the signed buffer as a Uint8Array.
+   * @throws {Error} If the private key is invalid.
    */
   async signBuffer(buffer) {
     if (typeof this.nativeSigner.defaultPrivateKey !== "string") {
@@ -453,12 +774,26 @@ var TronWebSigner = class _TronWebSigner {
     const retval = ethers.ethers.utils.arrayify(signedMessage);
     return Promise.resolve(retval);
   }
+  /**
+   * Validates a transaction.
+   *
+   * @param {ethers.PopulatedTransaction} transaction - The transaction to validate.
+   * @returns {boolean} True if the transaction is valid, false otherwise.
+   * @throws {Error} If the transaction is invalid.
+   */
   static validateTransaction(transaction) {
     if (transaction.data === void 0 || transaction.to === void 0) {
       throw new Error("Invalid transaction, missing data or to");
     }
     return true;
   }
+  /**
+   * Builds a transaction.
+   *
+   * @param {unknown} buildTxRequest - The transaction request to build.
+   * @returns {Promise<TransactionRequest>} A promise that resolves to the built transaction request.
+   * @throws {Error} Method not implemented.
+   */
   async buildTransaction(buildTxRequest) {
     return Promise.reject(new Error("Method not implemented."));
   }