@aptos-labs/ts-sdk 1.29.1 → 1.31.0

package/src/core/crypto/poseidon.ts

@@ -42,9 +42,12 @@ const MAX_NUM_INPUT_SCALARS = 16;
 const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
 
 /**
- * Hashes a string to a field element via poseidon
+ * Hashes a string to a field element via Poseidon hashing.
+ * This function is useful for converting a string into a fixed-size hash that can be used in cryptographic applications.
  *
- * @returns bigint result of the hash
+ * @param str - The string to be hashed.
+ * @param maxSizeBytes - The maximum size in bytes for the resulting hash.
+ * @returns bigint - The result of the hash.
  */
 export function hashStrToField(str: string, maxSizeBytes: number): bigint {
   const textEncoder = new TextEncoder();
@@ -52,6 +55,14 @@ export function hashStrToField(str: string, maxSizeBytes: number): bigint {
   return hashBytesWithLen(strBytes, maxSizeBytes);
 }
 
+/**
+ * Computes a Poseidon hash of the provided byte array, ensuring that the byte array does not exceed the specified maximum size.
+ * This function is useful for generating a hash from a byte array while enforcing size constraints.
+ *
+ * @param bytes - The byte array to be hashed.
+ * @param maxSizeBytes - The maximum allowed size for the byte array.
+ * @throws Error if the length of the inputted bytes exceeds the specified maximum size.
+ */
 function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {
   if (bytes.length > maxSizeBytes) {
     throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
@@ -60,6 +71,14 @@ function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {
   return poseidonHash(packed);
 }
 
+/**
+ * Pads the input byte array with zeros to a specified maximum size and then packs the bytes.
+ * This function ensures that the byte array does not exceed the specified maximum size, throwing an error if it does.
+ *
+ * @param bytes - The byte array to be padded and packed.
+ * @param maxSizeBytes - The maximum size in bytes that the input array can have.
+ * @throws Error if the input byte array exceeds the specified maximum size.
+ */
 function padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
   if (bytes.length > maxSizeBytes) {
     throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
@@ -68,6 +87,16 @@ function padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[]
   return packBytes(paddedStrBytes);
 }
 
+/**
+ * Pads and packs the given byte array to a specified maximum size and appends its length.
+ * This function ensures that the byte array does not exceed the maximum size, throwing an error if it does.
+ * It is useful for preparing byte data for further processing or transmission by ensuring a consistent format.
+ *
+ * @param bytes - The byte array to be padded and packed.
+ * @param maxSizeBytes - The maximum allowed size for the byte array.
+ * @throws Error if the length of the input bytes exceeds the maximum size.
+ * @returns A new Uint8Array that contains the padded and packed bytes along with the length of the original byte array.
+ */
 export function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
   if (bytes.length > maxSizeBytes) {
     throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
@@ -75,6 +104,11 @@ export function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number):
   return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
 }
 
+/**
+ * Packs a Uint8Array into an array of BigInts, ensuring the input does not exceed the maximum allowed bytes.
+ * @param bytes - The Uint8Array to be packed.
+ * @throws {Error} Throws an error if the input exceeds the maximum number of bytes allowed.
+ */
 function packBytes(bytes: Uint8Array): bigint[] {
   if (bytes.length > MAX_NUM_INPUT_BYTES) {
     throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
@@ -82,6 +116,14 @@ function packBytes(bytes: Uint8Array): bigint[] {
   return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
 }
 
+/**
+ * Splits a Uint8Array into smaller chunks of the specified size.
+ * This function is useful for processing large arrays in manageable segments.
+ *
+ * @param array - The Uint8Array to be split into chunks.
+ * @param chunkSize - The size of each chunk.
+ * @returns An array of Uint8Array chunks.
+ */
 function chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {
   const result: Uint8Array[] = [];
   for (let i = 0; i < array.length; i += chunkSize) {
@@ -90,6 +132,13 @@ function chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {
   return result;
 }
 
+/**
+ * Converts a little-endian byte array into a BigInt.
+ * This function is useful for interpreting byte data as a numerical value in a way that respects the little-endian format.
+ *
+ * @param bytes - The byte array to convert.
+ * @returns The resulting BigInt representation of the byte array.
+ */
 export function bytesToBigIntLE(bytes: Uint8Array): bigint {
   let result = BigInt(0);
   for (let i = bytes.length - 1; i >= 0; i -= 1) {
@@ -98,6 +147,15 @@ export function bytesToBigIntLE(bytes: Uint8Array): bigint {
   return result;
 }
 
+/**
+ * Converts a bigint value into a little-endian byte array of a specified length.
+ * This function is useful for representing large integers in a byte format, which is often required for cryptographic operations
+ * or binary data manipulation.
+ *
+ * @param value - The number to convert into bytes.
+ * @param length - The desired length of the resulting byte array.
+ * @returns A Uint8Array containing the little-endian representation of the bigint value.
+ */
 export function bigIntToBytesLE(value: bigint | number, length: number): Uint8Array {
   let val = BigInt(value);
   const bytes = new Uint8Array(length);
@@ -108,6 +166,14 @@ export function bigIntToBytesLE(value: bigint | number, length: number): Uint8Ar
   return bytes;
 }
 
+/**
+ * Pads the input Uint8Array with zeros to achieve the specified size.
+ * This function is useful for ensuring that a byte array meets a required length for further processing.
+ *
+ * @param inputArray - The Uint8Array to be padded.
+ * @param paddedSize - The desired size of the padded array, which must be greater than or equal to the input array size.
+ * @throws Error if paddedSize is less than the length of inputArray.
+ */
 function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uint8Array {
   if (paddedSize < inputArray.length) {
     throw new Error("Padded size must be greater than or equal to the input array size.");
@@ -128,11 +194,12 @@ function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uin
 }
 
 /**
- * Hashes up to 16 scalar elements via the poseidon hashing algorithm.
- *
+ * Hashes up to 16 scalar elements via the Poseidon hashing algorithm.
  * Each element must be scalar fields of the BN254 elliptic curve group.
  *
- * @returns bigint result of the hash
+ * @param inputs - An array of elements to be hashed, which can be of type number, bigint, or string.
+ * @returns bigint - The result of the hash.
+ * @throws Error - Throws an error if the input length exceeds the maximum allowed.
  */
 export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
   if (inputs.length > numInputsToPoseidonFunc.length) {

package/src/core/crypto/privateKey.ts

@@ -3,18 +3,22 @@ import { PublicKey } from "./publicKey";
 import { Signature } from "./signature";
 
 /**
- * An abstract representation of a private key.
- * It is associated to a signature scheme and provides signing capabilities.
+ * Represents a private key used for signing messages and deriving the associated public key.
+ *
+ * @method sign - Signs the given message with the private key.
+ * @method publicKey - Derives the public key associated with the private key.
+ * @method toUint8Array - Retrieves the private key in bytes.
  */
 export interface PrivateKey {
   /**
-   * Sign the given message with the private key.
-   * @param message in HexInput format
+   * Sign the given message with the private key to create a signature.
+   * @param message - The message to be signed, provided in HexInput format.
+   * @returns A Signature object representing the signed message.
    */
   sign(message: HexInput): Signature;
 
   /**
-   * Derive the public key associated with the private key
+   * Derive the public key associated with the private key.
    */
   publicKey(): PublicKey;
 

package/src/core/crypto/proof.ts

@@ -1,16 +1,7 @@
 import { Serializable } from "../../bcs";
-import { Hex } from "../hex";
 
 /**
- * An abstract representation of a crypto proof.
- * associated to a specific zero knowledge proof schemes e.g. Groth16, PLONK
+ * An abstract representation of a cryptographic proof associated with specific
+ * zero-knowledge proof schemes, such as Groth16 and PLONK.
  */
-export abstract class Proof extends Serializable {
-  /**
-   * Get the proof as a hex string with a 0x prefix e.g. 0x123456...
-   */
-  toString(): string {
-    const bytes = this.bcsToBytes();
-    return Hex.fromHexInput(bytes).toString();
-  }
-}
+export abstract class Proof extends Serializable {}

package/src/core/crypto/publicKey.ts

@@ -5,7 +5,10 @@ import { Hex } from "../hex";
 import { Signature } from "./signature";
 
 /**
- * Arguments for verifying a signature
+ * Represents the arguments required to verify a digital signature.
+ *
+ * @param message - The original message that was signed.
+ * @param signature - The signature to be verified against the message.
  */
 export interface VerifySignatureArgs {
   message: HexInput;
@@ -13,9 +16,10 @@ export interface VerifySignatureArgs {
 }
 
 /**
- * An abstract representation of a public key.
+ * Represents an abstract public key.
  *
- * Provides a common interface for verifying any signature.
+ * This class provides a common interface for verifying signatures associated with the public key.
+ * It allows for the retrieval of the raw public key bytes and the public key in a hexadecimal string format.
  */
 export abstract class PublicKey extends Serializable {
   /**
@@ -28,10 +32,14 @@ export abstract class PublicKey extends Serializable {
   /**
    * Get the raw public key bytes
    */
-  abstract toUint8Array(): Uint8Array;
+  toUint8Array(): Uint8Array {
+    return this.bcsToBytes();
+  }
 
   /**
-   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
+   * Get the public key as a hex string with a 0x prefix.
+   *
+   * @returns The public key in hex format.
    */
   toString(): string {
     const bytes = this.toUint8Array();
@@ -43,6 +51,8 @@ export abstract class PublicKey extends Serializable {
  * An abstract representation of an account public key.
  *
  * Provides a common interface for deriving an authentication key.
+ *
+ * @abstract
  */
 export abstract class AccountPublicKey extends PublicKey {
   /**

package/src/core/crypto/secp256k1.ts

@@ -14,9 +14,11 @@ import { Signature } from "./signature";
 import { convertSigningMessage } from "./utils";
 
 /**
- * Represents the Secp256k1 ecdsa public key
+ * Represents a Secp256k1 ECDSA public key.
  *
- * Secp256k1 authentication key is represented in the SDK as `AnyPublicKey`.
+ * @extends PublicKey
+ * @static
+ * @property LENGTH - The length of the Secp256k1 public key in bytes.
  */
 export class Secp256k1PublicKey extends PublicKey {
   // Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.
@@ -26,9 +28,11 @@ export class Secp256k1PublicKey extends PublicKey {
   private readonly key: Hex;
 
   /**
-   * Create a new PublicKey instance from a Uint8Array or String.
+   * Create a new PublicKey instance from a HexInput, which can be a string or Uint8Array.
+   * This constructor validates the length of the provided signature data.
    *
-   * @param hexInput A HexInput (string or Uint8Array)
+   * @param hexInput - A HexInput (string or Uint8Array) representing the signature data.
+   * @throws Error if the length of the signature data is not equal to Secp256k1Signature.LENGTH.
    */
   constructor(hexInput: HexInput) {
     super();
@@ -42,9 +46,13 @@ export class Secp256k1PublicKey extends PublicKey {
 
   // region PublicKey
   /**
-   * Verifies a Secp256k1 signature against the public key
+   * Verifies a Secp256k1 signature against the public key.
+   *
+   * This function checks the validity of a signature for a given message, ensuring that the signature is canonical as a malleability check.
    *
-   * Note signatures are validated to be canonical as a malleability check
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify against the public key.
    */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
@@ -55,6 +63,11 @@ export class Secp256k1PublicKey extends PublicKey {
     return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
   }
 
+  /**
+   * Get the data as a Uint8Array representation.
+   *
+   * @returns Uint8Array representation of the data.
+   */
   toUint8Array(): Uint8Array {
     return this.key.toUint8Array();
   }
@@ -63,10 +76,28 @@ export class Secp256k1PublicKey extends PublicKey {
 
   // region Serializable
 
+  /**
+   * Serializes the data into a byte array using the provided serializer.
+   * This function is essential for converting data into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to convert the data.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.key.toUint8Array());
   }
 
+  /**
+   * Deserializes a Secp256k1Signature from the provided deserializer.
+   * This function allows you to reconstruct a Secp256k1Signature object from its serialized byte representation.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  deserialize(deserializer: Deserializer) {
+    const hex = deserializer.deserializeBytes();
+    return new Secp256k1Signature(hex);
+  }
+
   static deserialize(deserializer: Deserializer): Secp256k1PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new Secp256k1PublicKey(bytes);
@@ -75,20 +106,30 @@ export class Secp256k1PublicKey extends PublicKey {
   // endregion
 
   /**
+   * Determine if the provided public key is an instance of Secp256k1PublicKey.
+   *
    * @deprecated use `instanceof Secp256k1PublicKey` instead
-   * @param publicKey
+   * @param publicKey - The public key to check.
    */
   static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
     return publicKey instanceof Secp256k1PublicKey;
   }
 
+  /**
+   * Determines if the provided public key is a valid instance of a Secp256k1 public key.
+   * This function checks for the presence of a "key" property and validates the length of the key data.
+   *
+   * @param publicKey - The public key to validate.
+   * @returns A boolean indicating whether the public key is a valid Secp256k1 public key.
+   */
   static isInstance(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
     return "key" in publicKey && (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH;
   }
 }
 
 /**
- * A Secp256k1 ecdsa private key
+ * Represents a Secp256k1 ECDSA private key, providing functionality to create, sign messages,
+ * derive public keys, and serialize/deserialize the key.
  */
 export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
@@ -123,7 +164,7 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
    * Generate a new random private key.
    *
-   * @returns Secp256k1PrivateKey
+   * @returns Secp256k1PrivateKey - A newly generated Secp256k1 private key.
    */
   static generate(): Secp256k1PrivateKey {
     const hexInput = secp256k1.utils.randomPrivateKey();
@@ -131,12 +172,14 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   }
 
   /**
-   * Derives a private key from a mnemonic seed phrase.
+   * Derives a private key from a mnemonic seed phrase using a specified BIP44 path.
    *
-   * @param path the BIP44 path
-   * @param mnemonics the mnemonic seed phrase
+   * @param path - The BIP44 path to derive the key from.
+   * @param mnemonics - The mnemonic seed phrase used for key generation.
    *
-   * @returns The generated key
+   * @returns The generated private key.
+   *
+   * @throws Error if the provided path is not a valid BIP44 path.
    */
   static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey {
     if (!isValidBIP44Path(path)) {
@@ -146,13 +189,13 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   }
 
   /**
-   * A private inner function so we can separate from the main fromDerivationPath() method
-   * to add tests to verify we create the keys correctly.
-   *
-   * @param path the BIP44 path
-   * @param seed the seed phrase created by the mnemonics
+   * Derives a private key from a specified BIP44 path using a given seed.
+   * This function is essential for generating keys that follow the hierarchical deterministic (HD) wallet structure.
    *
-   * @returns The generated key
+   * @param path - The BIP44 path used for key derivation.
+   * @param seed - The seed phrase created by the mnemonics, represented as a Uint8Array.
+   * @returns The generated private key as an instance of Secp256k1PrivateKey.
+   * @throws Error if the derived private key is invalid.
    */
   private static fromDerivationPathInner(path: string, seed: Uint8Array): Secp256k1PrivateKey {
     const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);
@@ -170,11 +213,10 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
 
   /**
    * Sign the given message with the private key.
+   * This function generates a cryptographic signature for the provided message, ensuring the signature is canonical and non-malleable.
    *
-   * Note: signatures are canonical, and non-malleable
-   *
-   * @param message a message as a string or Uint8Array
-   * @returns Signature
+   * @param message - A message in HexInput format to be signed.
+   * @returns Signature - The generated signature for the provided message.
    */
   sign(message: HexInput): Secp256k1Signature {
     const messageToSign = convertSigningMessage(message);
@@ -187,7 +229,7 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
    * Derive the Secp256k1PublicKey from this private key.
    *
-   * @returns Secp256k1PublicKey
+   * @returns Secp256k1PublicKey The derived public key.
    */
   publicKey(): Secp256k1PublicKey {
     const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
@@ -204,7 +246,7 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   }
 
   /**
-   * Get the private key as a hex string with the 0x prefix.
+   * Get the private key as a string representation.
    *
    * @returns string representation of the private key
    */
@@ -228,6 +270,10 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   // endregion
 
   /**
+   * Determines if the provided private key is an instance of Secp256k1PrivateKey.
+   *
+   * @param privateKey - The private key to be checked.
+   *
    * @deprecated use `instanceof Secp256k1PrivateKey` instead
    */
   static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {
@@ -236,7 +282,11 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
 }
 
 /**
- * A signature of a message signed using a Secp256k1 ecdsa private key
+ * Represents a signature of a message signed using a Secp256k1 ECDSA private key.
+ *
+ * @static
+ * @readonly
+ * @length The length of Secp256k1 ECDSA signatures, which is 64 bytes.
  */
 export class Secp256k1Signature extends Signature {
   /**

package/src/core/crypto/signature.ts

@@ -3,19 +3,22 @@ import { Hex } from "../hex";
 
 /**
  * An abstract representation of a crypto signature,
- * associated to a specific signature scheme e.g. Ed25519 or Secp256k1
+ * associated with a specific signature scheme, e.g., Ed25519 or Secp256k1.
  *
- * This is the product of signing a message directly from a PrivateKey
- * and can be verified against a CryptoPublicKey.
+ * This class represents the product of signing a message directly from a
+ * PrivateKey and can be verified against a CryptoPublicKey.
  */
 export abstract class Signature extends Serializable {
   /**
    * Get the raw signature bytes
    */
-  abstract toUint8Array(): Uint8Array;
+  toUint8Array(): Uint8Array {
+    return this.bcsToBytes();
+  }
 
   /**
    * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
+   * @returns The hex string representation of the signature.
    */
   toString(): string {
     const bytes = this.toUint8Array();

package/src/core/crypto/singleKey.ts

@@ -29,6 +29,13 @@ export class AnyPublicKey extends AccountPublicKey {
 
   // region Constructors
 
+  /**
+   * Creates an instance of the signature class based on the provided signature type.
+   * This allows for the handling of different signature variants such as Ed25519, Secp256k1, and Keyless.
+   *
+   * @param publicKey - The publicKey object which determines the variant to be used.
+   * @throws Error if the provided signature type is unsupported.
+   */
   constructor(publicKey: PublicKey) {
     super();
     this.publicKey = publicKey;
@@ -49,6 +56,15 @@ export class AnyPublicKey extends AccountPublicKey {
 
   // region AccountPublicKey
 
+  /**
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
+   *
+   * @param args - The arguments for signature verification.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify, which must be an instance of AnySignature.
+   * @returns A boolean indicating whether the signature is valid for the given message.
+   */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
     if (!AnySignature.isInstance(signature)) {
@@ -61,6 +77,12 @@ export class AnyPublicKey extends AccountPublicKey {
     });
   }
 
+  /**
+   * Generates an authentication key from the current instance's byte representation.
+   * This function is essential for creating a unique identifier for authentication purposes.
+   *
+   * @returns {AuthenticationKey} The generated authentication key.
+   */
   authKey(): AuthenticationKey {
     return AuthenticationKey.fromSchemeAndBytes({
       scheme: AuthenticationKeyScheme.SingleKey,
@@ -68,6 +90,14 @@ export class AnyPublicKey extends AccountPublicKey {
     });
   }
 
+  /**
+   * Get the signature in bytes (Uint8Array).
+   *
+   * This function is a warning that it will soon return the underlying signature bytes directly.
+   * Use AnySignature.bcsToBytes() instead.
+   *
+   * @returns Uint8Array representation of the signature.
+   */
   toUint8Array() {
     return this.bcsToBytes();
   }
@@ -76,11 +106,23 @@ export class AnyPublicKey extends AccountPublicKey {
 
   // region Serializable
 
+  /**
+   * Serializes the current object using the provided serializer.
+   * This function helps in converting the object into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(this.variant);
     this.publicKey.serialize(serializer);
   }
 
+  /**
+   * Deserializes an AnySignature from the provided deserializer.
+   * This function helps in reconstructing the AnySignature object from its serialized form, allowing for further processing or validation.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): AnyPublicKey {
     const variantIndex = deserializer.deserializeUleb128AsU32();
     let publicKey: PublicKey;
@@ -102,17 +144,21 @@ export class AnyPublicKey extends AccountPublicKey {
     }
     return new AnyPublicKey(publicKey);
   }
-
   // endregion
 
   /**
-   * @deprecated use `instanceof AnyPublicKey` instead.
+   * Determines if the provided public key is an instance of AnyPublicKey.
+   *
+   * @param publicKey - The public key to check.
+   * @deprecated Use `instanceof AnyPublicKey` instead.
    */
   static isPublicKey(publicKey: AccountPublicKey): publicKey is AnyPublicKey {
     return publicKey instanceof AnyPublicKey;
   }
 
   /**
+   * Determines if the current public key is an instance of Ed25519PublicKey.
+   *
    * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
    */
   isEd25519(): boolean {
@@ -120,21 +166,32 @@ export class AnyPublicKey extends AccountPublicKey {
   }
 
   /**
+   * Checks if the public key is an instance of Secp256k1PublicKey.
+   *
    * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
    */
   isSecp256k1PublicKey(): boolean {
     return this.publicKey instanceof Secp256k1PublicKey;
   }
 
+  /**
+   * Determines if the provided publicKey is an instance of a valid PublicKey object.
+   *
+   * @param publicKey - The publicKey to be checked for validity.
+   * @param publicKey.publicKey - The actual publicKey object that needs to be validated.
+   * @returns True if the signature is a valid instance; otherwise, false.
+   */
   static isInstance(publicKey: PublicKey): publicKey is AnyPublicKey {
     return "publicKey" in publicKey && "variant" in publicKey;
   }
 }
 
 /**
- * Instance of signature that uses the SingleKey authentication scheme.
- * This signature can only be generated by a `SingleKeySigner`, since it uses the
- * same authentication scheme.
+ * Represents a signature that utilizes the SingleKey authentication scheme.
+ * This class is designed to encapsulate various types of signatures, which can
+ * only be generated by a `SingleKeySigner` due to the shared authentication mechanism.
+ *
+ * @extends Signature
  */
 export class AnySignature extends Signature {
   public readonly signature: Signature;