@layerzerolabs/lz-corekit-solana 3.0.15 → 3.0.16

package/dist/index.mjs

@@ -1,395 +1,10 @@
 import { Connection, PublicKey, Keypair, sendAndConfirmRawTransaction } from '@solana/web3.js';
 import { Block, TransactionResponse, TransactionReceipt, BlockWithTransactions, TransactionPending, SignedTransaction } from '@layerzerolabs/lz-core';
+import { arrayify } from '@layerzerolabs/lz-utilities';
 import * as bip39 from 'bip39';
 import { derivePath } from 'ed25519-hd-key';
 
 // src/providers/solana.ts
-
-// ../../../node_modules/.store/@ethersproject-logger-npm-5.7.0-63fe9c3d29/package/lib.esm/_version.js
-var version = "logger/5.7.0";
-
-// ../../../node_modules/.store/@ethersproject-logger-npm-5.7.0-63fe9c3d29/package/lib.esm/index.js
-var _permanentCensorErrors = false;
-var _censorErrors = false;
-var LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
-var _logLevel = LogLevels["default"];
-var _globalLogger = null;
-function _checkNormalize() {
-  try {
-    const missing = [];
-    ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
-      try {
-        if ("test".normalize(form) !== "test") {
-          throw new Error("bad normalize");
-        }
-        ;
-      } catch (error) {
-        missing.push(form);
-      }
-    });
-    if (missing.length) {
-      throw new Error("missing " + missing.join(", "));
-    }
-    if (String.fromCharCode(233).normalize("NFD") !== String.fromCharCode(101, 769)) {
-      throw new Error("broken implementation");
-    }
-  } catch (error) {
-    return error.message;
-  }
-  return null;
-}
-var _normalizeError = _checkNormalize();
-var LogLevel;
-(function(LogLevel2) {
-  LogLevel2["DEBUG"] = "DEBUG";
-  LogLevel2["INFO"] = "INFO";
-  LogLevel2["WARNING"] = "WARNING";
-  LogLevel2["ERROR"] = "ERROR";
-  LogLevel2["OFF"] = "OFF";
-})(LogLevel || (LogLevel = {}));
-var ErrorCode;
-(function(ErrorCode2) {
-  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-  ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
-  ErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
-  ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  ErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
-  ErrorCode2["TIMEOUT"] = "TIMEOUT";
-  ErrorCode2["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
-  ErrorCode2["NUMERIC_FAULT"] = "NUMERIC_FAULT";
-  ErrorCode2["MISSING_NEW"] = "MISSING_NEW";
-  ErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
-  ErrorCode2["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
-  ErrorCode2["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
-  ErrorCode2["CALL_EXCEPTION"] = "CALL_EXCEPTION";
-  ErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-  ErrorCode2["NONCE_EXPIRED"] = "NONCE_EXPIRED";
-  ErrorCode2["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
-  ErrorCode2["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
-  ErrorCode2["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
-  ErrorCode2["ACTION_REJECTED"] = "ACTION_REJECTED";
-})(ErrorCode || (ErrorCode = {}));
-var HEX = "0123456789abcdef";
-var Logger = class _Logger {
-  constructor(version3) {
-    Object.defineProperty(this, "version", {
-      enumerable: true,
-      value: version3,
-      writable: false
-    });
-  }
-  _log(logLevel, args) {
-    const level = logLevel.toLowerCase();
-    if (LogLevels[level] == null) {
-      this.throwArgumentError("invalid log level name", "logLevel", logLevel);
-    }
-    if (_logLevel > LogLevels[level]) {
-      return;
-    }
-    console.log.apply(console, args);
-  }
-  debug(...args) {
-    this._log(_Logger.levels.DEBUG, args);
-  }
-  info(...args) {
-    this._log(_Logger.levels.INFO, args);
-  }
-  warn(...args) {
-    this._log(_Logger.levels.WARNING, args);
-  }
-  makeError(message, code, params) {
-    if (_censorErrors) {
-      return this.makeError("censored error", code, {});
-    }
-    if (!code) {
-      code = _Logger.errors.UNKNOWN_ERROR;
-    }
-    if (!params) {
-      params = {};
-    }
-    const messageDetails = [];
-    Object.keys(params).forEach((key) => {
-      const value = params[key];
-      try {
-        if (value instanceof Uint8Array) {
-          let hex = "";
-          for (let i = 0; i < value.length; i++) {
-            hex += HEX[value[i] >> 4];
-            hex += HEX[value[i] & 15];
-          }
-          messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
-        } else {
-          messageDetails.push(key + "=" + JSON.stringify(value));
-        }
-      } catch (error2) {
-        messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
-      }
-    });
-    messageDetails.push(`code=${code}`);
-    messageDetails.push(`version=${this.version}`);
-    const reason = message;
-    let url = "";
-    switch (code) {
-      case ErrorCode.NUMERIC_FAULT: {
-        url = "NUMERIC_FAULT";
-        const fault = message;
-        switch (fault) {
-          case "overflow":
-          case "underflow":
-          case "division-by-zero":
-            url += "-" + fault;
-            break;
-          case "negative-power":
-          case "negative-width":
-            url += "-unsupported";
-            break;
-          case "unbound-bitwise-result":
-            url += "-unbound-result";
-            break;
-        }
-        break;
-      }
-      case ErrorCode.CALL_EXCEPTION:
-      case ErrorCode.INSUFFICIENT_FUNDS:
-      case ErrorCode.MISSING_NEW:
-      case ErrorCode.NONCE_EXPIRED:
-      case ErrorCode.REPLACEMENT_UNDERPRICED:
-      case ErrorCode.TRANSACTION_REPLACED:
-      case ErrorCode.UNPREDICTABLE_GAS_LIMIT:
-        url = code;
-        break;
-    }
-    if (url) {
-      message += " [ See: https://links.ethers.org/v5-errors-" + url + " ]";
-    }
-    if (messageDetails.length) {
-      message += " (" + messageDetails.join(", ") + ")";
-    }
-    const error = new Error(message);
-    error.reason = reason;
-    error.code = code;
-    Object.keys(params).forEach(function(key) {
-      error[key] = params[key];
-    });
-    return error;
-  }
-  throwError(message, code, params) {
-    throw this.makeError(message, code, params);
-  }
-  throwArgumentError(message, name, value) {
-    return this.throwError(message, _Logger.errors.INVALID_ARGUMENT, {
-      argument: name,
-      value
-    });
-  }
-  assert(condition, message, code, params) {
-    if (!!condition) {
-      return;
-    }
-    this.throwError(message, code, params);
-  }
-  assertArgument(condition, message, name, value) {
-    if (!!condition) {
-      return;
-    }
-    this.throwArgumentError(message, name, value);
-  }
-  checkNormalize(message) {
-    if (_normalizeError) {
-      this.throwError("platform missing String.prototype.normalize", _Logger.errors.UNSUPPORTED_OPERATION, {
-        operation: "String.prototype.normalize",
-        form: _normalizeError
-      });
-    }
-  }
-  checkSafeUint53(value, message) {
-    if (typeof value !== "number") {
-      return;
-    }
-    if (message == null) {
-      message = "value not safe";
-    }
-    if (value < 0 || value >= 9007199254740991) {
-      this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
-        operation: "checkSafeInteger",
-        fault: "out-of-safe-range",
-        value
-      });
-    }
-    if (value % 1) {
-      this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
-        operation: "checkSafeInteger",
-        fault: "non-integer",
-        value
-      });
-    }
-  }
-  checkArgumentCount(count, expectedCount, message) {
-    if (message) {
-      message = ": " + message;
-    } else {
-      message = "";
-    }
-    if (count < expectedCount) {
-      this.throwError("missing argument" + message, _Logger.errors.MISSING_ARGUMENT, {
-        count,
-        expectedCount
-      });
-    }
-    if (count > expectedCount) {
-      this.throwError("too many arguments" + message, _Logger.errors.UNEXPECTED_ARGUMENT, {
-        count,
-        expectedCount
-      });
-    }
-  }
-  checkNew(target, kind) {
-    if (target === Object || target == null) {
-      this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
-    }
-  }
-  checkAbstract(target, kind) {
-    if (target === kind) {
-      this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", _Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
-    } else if (target === Object || target == null) {
-      this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
-    }
-  }
-  static globalLogger() {
-    if (!_globalLogger) {
-      _globalLogger = new _Logger(version);
-    }
-    return _globalLogger;
-  }
-  static setCensorship(censorship, permanent) {
-    if (!censorship && permanent) {
-      this.globalLogger().throwError("cannot permanently disable censorship", _Logger.errors.UNSUPPORTED_OPERATION, {
-        operation: "setCensorship"
-      });
-    }
-    if (_permanentCensorErrors) {
-      if (!censorship) {
-        return;
-      }
-      this.globalLogger().throwError("error censorship permanent", _Logger.errors.UNSUPPORTED_OPERATION, {
-        operation: "setCensorship"
-      });
-    }
-    _censorErrors = !!censorship;
-    _permanentCensorErrors = !!permanent;
-  }
-  static setLogLevel(logLevel) {
-    const level = LogLevels[logLevel.toLowerCase()];
-    if (level == null) {
-      _Logger.globalLogger().warn("invalid log level - " + logLevel);
-      return;
-    }
-    _logLevel = level;
-  }
-  static from(version3) {
-    return new _Logger(version3);
-  }
-};
-Logger.errors = ErrorCode;
-Logger.levels = LogLevel;
-
-// ../../../node_modules/.store/@ethersproject-bytes-npm-5.7.0-4454fe4cb0/package/lib.esm/_version.js
-var version2 = "bytes/5.7.0";
-
-// ../../../node_modules/.store/@ethersproject-bytes-npm-5.7.0-4454fe4cb0/package/lib.esm/index.js
-var logger = new Logger(version2);
-function isHexable(value) {
-  return !!value.toHexString;
-}
-function addSlice(array) {
-  if (array.slice) {
-    return array;
-  }
-  array.slice = function() {
-    const args = Array.prototype.slice.call(arguments);
-    return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
-  };
-  return array;
-}
-function isInteger(value) {
-  return typeof value === "number" && value == value && value % 1 === 0;
-}
-function isBytes(value) {
-  if (value == null) {
-    return false;
-  }
-  if (value.constructor === Uint8Array) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return false;
-  }
-  if (!isInteger(value.length) || value.length < 0) {
-    return false;
-  }
-  for (let i = 0; i < value.length; i++) {
-    const v = value[i];
-    if (!isInteger(v) || v < 0 || v >= 256) {
-      return false;
-    }
-  }
-  return true;
-}
-function arrayify(value, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid arrayify value");
-    const result = [];
-    while (value) {
-      result.unshift(value & 255);
-      value = parseInt(String(value / 256));
-    }
-    if (result.length === 0) {
-      result.push(0);
-    }
-    return addSlice(new Uint8Array(result));
-  }
-  if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
-    value = "0x" + value;
-  }
-  if (isHexable(value)) {
-    value = value.toHexString();
-  }
-  if (isHexString(value)) {
-    let hex = value.substring(2);
-    if (hex.length % 2) {
-      if (options.hexPad === "left") {
-        hex = "0" + hex;
-      } else if (options.hexPad === "right") {
-        hex += "0";
-      } else {
-        logger.throwArgumentError("hex data is odd-length", "value", value);
-      }
-    }
-    const result = [];
-    for (let i = 0; i < hex.length; i += 2) {
-      result.push(parseInt(hex.substring(i, i + 2), 16));
-    }
-    return addSlice(new Uint8Array(result));
-  }
-  if (isBytes(value)) {
-    return addSlice(new Uint8Array(value));
-  }
-  return logger.throwArgumentError("invalid arrayify value", "value", value);
-}
-function isHexString(value, length) {
-  if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-    return false;
-  }
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  return true;
-}
-
-// src/utils.ts
 function toRawTransaction(transaction) {
   const retval = typeof transaction === "string" ? arrayify(transaction) : transaction.serialize();
   return retval;
@@ -397,10 +12,22 @@ function toRawTransaction(transaction) {
 
 // src/providers/solana.ts
 var SolanaProvider = class _SolanaProvider {
+  /**
+   * Creates an instance of SolanaProvider.
+   *
+   * @param {string} url - The URL of the Solana node.
+   */
   constructor(url) {
     this.url = url;
     this.nativeProvider = new Connection(url, "confirmed");
   }
+  /**
+   * Creates an instance of SolanaProvider from the given source.
+   *
+   * @param {string} source - The source to create the provider from.
+   * @returns {SolanaProvider} The created SolanaProvider instance.
+   * @throws {Error} If the source parameter is invalid.
+   */
   static from(source) {
     if (typeof source === "string") {
       return new _SolanaProvider(source);
@@ -408,24 +35,59 @@ var SolanaProvider = class _SolanaProvider {
       throw new Error("Invalid parameters");
     }
   }
+  /**
+   * Gets the native Solana provider instance.
+   *
+   * @returns {Connection} The native Solana 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.getBalance(new PublicKey(address)).then((balance) => balance.toString());
   }
+  /**
+   * Gets the block specified by slot.
+   *
+   * @param {BlockTag} slot - The slot to specify the block.
+   * @returns {Promise<Block>} A promise that resolves to the block.
+   */
   async getBlock(slot) {
     const response = await this.nativeProvider.getParsedBlock(parseInt(slot.toString()), {
       commitment: "confirmed"
     });
     return Block.from(response);
   }
+  /**
+   * Gets the current block number.
+   *
+   * @returns {Promise<number>} A promise that resolves to the current block number.
+   */
   async getBlockNumber() {
     return this.nativeProvider.getBlockHeight({ commitment: "confirmed" });
   }
+  /**
+   * Gets the current slot number for commitment.
+   *
+   * @param {Finality} [finality] - The commitment level (optional).
+   * @returns {Promise<number>} A promise that resolves to the current slot number.
+   */
   async getSlot(finality) {
     return this.nativeProvider.getSlot(finality);
   }
+  /**
+   * Gets the UNIX timestamp for the block identified by slot.
+   *
+   * @param {BlockTag} slot - The slot to specify the block.
+   * @returns {Promise<number>} A promise that resolves to the UNIX timestamp of the block.
+   * @throws {Error} If the block timestamp is not available.
+   */
   async getBlockTimestamp(slot) {
     const t = await this.nativeProvider.getBlockTime(parseInt(slot.toString()));
     if (t === null) {
@@ -434,9 +96,10 @@ var SolanaProvider = class _SolanaProvider {
     return t;
   }
   /**
+   * Gets information about a transaction.
    *
-   * @param txHash string The transaction hash is TransactionSignature in Solana
-   * @returns TransactionResponse
+   * @param {string} txHash - The transaction hash is TransactionSignature in Solana
+   * @returns {Promise<TransactionResponse>} A promise that resolves to the transaction response
    */
   async getTransaction(txHash) {
     const response = await this.nativeProvider.getParsedTransaction(txHash, {
@@ -444,6 +107,13 @@ var SolanaProvider = class _SolanaProvider {
     });
     return TransactionResponse.from(response);
   }
+  /**
+   * Gets the receipt of a transaction.
+   *
+   * @param {string} txHash - The transaction hash is TransactionSignature in Solana
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   * @throws {Error} If the transaction is not found.
+   */
   async getTransactionReceipt(txHash) {
     const response = await this.nativeProvider.getParsedTransaction(txHash, {
       commitment: "confirmed"
@@ -453,11 +123,26 @@ var SolanaProvider = class _SolanaProvider {
     }
     return 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 implemented.
+   */
   // eslint-disable-next-line @typescript-eslint/require-await
   async getTransactionCount(_addressOrName, _blockTag) {
     await Promise.resolve();
     throw new Error("Method not implemented.");
   }
+  /**
+   * 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.
+   * @throws {Error} If the block is not found.
+   */
   async getBlockWithTransactions(blockTag) {
     if (typeof blockTag === "string") {
       blockTag = parseInt(blockTag);
@@ -468,12 +153,27 @@ var SolanaProvider = class _SolanaProvider {
     }
     return BlockWithTransactions.from(response);
   }
+  /**
+   * Sends a signed transaction to the blockchain.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {SendOptions} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, sendOptions) {
     const _transaction = transaction.signed;
     const rawTransaction = toRawTransaction(_transaction);
     const response = await this.nativeProvider.sendRawTransaction(rawTransaction, sendOptions);
     return TransactionPending.from(response);
   }
+  /**
+   * Confirms a pending transaction.
+   *
+   * @param {TransactionPending} pending - The pending transaction to confirm.
+   * @param {TransactionConfirmationStrategy} [opts] - Optional parameters for the confirmation.
+   * @returns {Promise<TransactionReceipt>} A promise that resolves to the transaction receipt.
+   * @throws {Error} If the transaction fails.
+   */
   async confirmTransaction(pending, opts) {
     const strategy = opts ?? await (async () => {
       const block = await this.nativeProvider.getLatestBlockhash("confirmed");
@@ -490,15 +190,35 @@ var SolanaProvider = class _SolanaProvider {
     }
     return Promise.resolve(TransactionReceipt.from(signature));
   }
+  /**
+   * 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?.send);
     return this.confirmTransaction(pending, opts?.confirm);
   }
 };
 var SolanaSigner = class {
+  /**
+   * Creates an instance of SolanaSigner.
+   *
+   * @param {Keypair} keypair - The Solana keypair to use as the signer.
+   */
   constructor(keypair) {
     this.keypair = keypair;
   }
+  /**
+   * Creates an instance of SolanaSigner from the given source.
+   *
+   * @param {Keypair | string} source - The source to create the signer from.
+   * @param {string} [path] - The derivation path (optional).
+   * @returns {SolanaSigner} The created SolanaSigner instance.
+   * @throws {Error} If the parameters are invalid.
+   */
   static from(source, path) {
     if (source instanceof Keypair) {
       return new this(source);
@@ -509,9 +229,21 @@ var SolanaSigner = class {
       throw new Error("Invalid parameters");
     }
   }
+  /**
+   * Gets the native Solana keypair instance.
+   *
+   * @returns {Keypair} The native Solana keypair instance.
+   */
   get native() {
     return this.keypair;
   }
+  /**
+   * Connects the signer to a provider.
+   *
+   * @param {Provider} provider - The provider to connect to.
+   * @returns {this} The connected signer.
+   * @throws {Error} If the provider is not an instance of Connection.
+   */
   connect(provider) {
     if (!(provider.native instanceof Connection)) {
       throw new Error("Only @solana/web3.js Connection is supported.");
@@ -519,18 +251,45 @@ var SolanaSigner = class {
     this.provider = provider.native;
     return this;
   }
+  /**
+   * Gets the address of the signer.
+   *
+   * @returns {Promise<string>} A promise that resolves to the address of the signer.
+   */
   async getAddress() {
     return Promise.resolve(this.keypair.publicKey.toBase58());
   }
+  /**
+   * Gets the address of the signer.
+   *
+   * @returns {string} The address of the signer.
+   */
   get address() {
     return this.publicKey.toBase58();
   }
+  /**
+   * Gets the public key of the signer.
+   *
+   * @returns {PublicKey} The public key of the signer.
+   */
   get publicKey() {
     return this.keypair.publicKey;
   }
+  /**
+   * Gets the secret key of the signer.
+   *
+   * @returns {Uint8Array} The secret key of the signer.
+   */
   get secretKey() {
     return this.keypair.secretKey;
   }
+  /**
+   * Sends a signed transaction and waits for confirmation.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {ConfirmOptions} [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 provider = this.assertAndGetProvider();
     const _transaction = transaction.signed;
@@ -538,6 +297,13 @@ var SolanaSigner = class {
     const response = await sendAndConfirmRawTransaction(provider, Buffer.from(rawTransaction), opts);
     return TransactionReceipt.from(response);
   }
+  /**
+   * Sends a signed transaction.
+   *
+   * @param {SignedTransaction} transaction - The signed transaction to send.
+   * @param {SendOptions} [sendOptions] - Optional parameters for sending the transaction.
+   * @returns {Promise<TransactionPending>} A promise that resolves to the pending transaction.
+   */
   async sendTransaction(transaction, sendOptions) {
     const provider = this.assertAndGetProvider();
     const _transaction = transaction.signed;
@@ -545,6 +311,13 @@ var SolanaSigner = class {
     const response = await provider.sendRawTransaction(rawTransaction, sendOptions);
     return TransactionPending.from(response);
   }
+  /**
+   * Signs a transaction.
+   *
+   * @param {TransactionRequest} transaction - The transaction request to sign.
+   * @param {Commitment | GetLatestBlockhashConfig} [opts] - Optional parameters for signing the transaction.
+   * @returns {Promise<SignedTransaction>} A promise that resolves to the signed transaction.
+   */
   async signTransaction(transaction, opts) {
     const tx = transaction.request;
     if (isVersionedTransaction(tx)) {
@@ -554,10 +327,22 @@ var SolanaSigner = class {
     }
     return Promise.resolve(SignedTransaction.from(tx));
   }
+  /**
+   * Signs a buffer (e.g., a message hash) using the native Solana signer.
+   *
+   * @param {Uint8Array} _buffer - The buffer to sign.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the signed buffer as a Uint8Array.
+   * @throws {Error} Method not implemented.
+   */
   async signBuffer(_buffer) {
     await Promise.resolve();
     throw new Error("Method not implemented.");
   }
+  /**
+   * Partially signs a transaction.
+   *
+   * @param {Transaction | VersionedTransaction} tx - The transaction to partially sign.
+   */
   partialSign(tx) {
     if (isVersionedTransaction(tx)) {
       tx.sign([this.keypair]);
@@ -565,12 +350,25 @@ var SolanaSigner = class {
       tx.partialSign(this.keypair);
     }
   }
+  /**
+   * Asserts that the provider is connected and returns it.
+   *
+   * @returns {Connection} The connected provider.
+   * @throws {Error} If the provider is not connected.
+   */
   assertAndGetProvider() {
     if (!this.provider) {
       throw new Error("Signer was not connected to a provider, did you forgot to connect to provider?");
     }
     return this.provider;
   }
+  /**
+   * 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."));
   }