@aptos-labs/ts-sdk 1.29.1 → 1.30.0

package/src/core/crypto/keyless.ts

@@ -36,9 +36,12 @@ export const MAX_JWT_HEADER_B64_BYTES = 300;
 export const MAX_COMMITED_EPK_BYTES = 93;
 
 /**
- * Represents the KeylessPublicKey public key
+ * Represents a Keyless Public Key used for authentication.
  *
- * KeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.
+ * This class encapsulates the public key functionality for keyless authentication,
+ * including methods for generating and verifying signatures, as well as serialization
+ * and deserialization of the key. The KeylessPublicKey is represented in the SDK
+ * as `AnyPublicKey`.
  */
 export class KeylessPublicKey extends AccountPublicKey {
   /**
@@ -58,6 +61,17 @@ export class KeylessPublicKey extends AccountPublicKey {
    */
   readonly idCommitment: Uint8Array;
 
+  /**
+   * Constructs an instance with the specified parameters for cryptographic operations.
+   *
+   * @param args - The parameters required to initialize the instance.
+   * @param args.alphaG1 - The hex representation of the alpha G1 value.
+   * @param args.betaG2 - The hex representation of the beta G2 value.
+   * @param args.deltaG2 - The hex representation of the delta G2 value.
+   * @param args.gammaAbcG1 - An array containing two hex representations for gamma ABC G1 values.
+   * @param args.gammaG2 - The hex representation of the gamma G2 value.
+   */
+  // TODO: Fix the JSDoc for the below values
   constructor(iss: string, idCommitment: HexInput) {
     super();
     const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
@@ -69,9 +83,9 @@ export class KeylessPublicKey extends AccountPublicKey {
   }
 
   /**
-   * Get the authentication key for the keyless public key
+   * Get the authentication key for the keyless public key.
    *
-   * @returns AuthenticationKey
+   * @returns AuthenticationKey - The authentication key derived from the keyless public key.
    */
   authKey(): AuthenticationKey {
     const serializer = new Serializer();
@@ -84,52 +98,68 @@ export class KeylessPublicKey extends AccountPublicKey {
   }
 
   /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString(): string {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
-  }
-
-  /**
-   * Verifies a signed data with a public key
+   * Verifies the validity of a signature for a given message.
    *
-   * @param args.message message
-   * @param args.signature The signature
-   * @returns true if 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 against the message.
+   * @returns true if the signature is valid; otherwise, false.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
   verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {
     throw new Error("Not yet implemented");
   }
 
+  /**
+   * Serializes the current instance into a format suitable for transmission or storage.
+   * This function ensures that all relevant fields are properly serialized, including the proof and optional fields.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @param serializer.proof - The proof to be serialized.
+   * @param serializer.expHorizonSecs - The expiration horizon in seconds.
+   * @param serializer.extraField - An optional additional field for serialization.
+   * @param serializer.overrideAudVal - An optional override value for auditing.
+   * @param serializer.trainingWheelsSignature - An optional signature for training wheels.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeStr(this.iss);
     serializer.serializeBytes(this.idCommitment);
   }
 
+  /**
+   * Deserializes a ZeroKnowledgeSig object from the provided deserializer.
+   * This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @returns A new instance of ZeroKnowledgeSig.
+   */
   static deserialize(deserializer: Deserializer): KeylessPublicKey {
     const iss = deserializer.deserializeStr();
     const addressSeed = deserializer.deserializeBytes();
     return new KeylessPublicKey(iss, addressSeed);
   }
 
+  /**
+   * Loads a KeylessPublicKey instance from the provided deserializer.
+   * This function is used to deserialize the necessary components to create a KeylessPublicKey.
+   *
+   * @param deserializer - The deserializer used to extract the string and byte data.
+   * @param deserializer.deserializeStr - A method to deserialize a string value.
+   * @param deserializer.deserializeBytes - A method to deserialize byte data.
+   * @returns A new instance of KeylessPublicKey.
+   */
   static load(deserializer: Deserializer): KeylessPublicKey {
     const iss = deserializer.deserializeStr();
     const addressSeed = deserializer.deserializeBytes();
     return new KeylessPublicKey(iss, addressSeed);
   }
 
+  /**
+   * Determines if the provided public key is an instance of KeylessPublicKey.
+   *
+   * @param publicKey - The public key to check.
+   * @returns A boolean indicating whether the public key is a KeylessPublicKey instance.
+   */
   static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey {
     return publicKey instanceof KeylessPublicKey;
   }
@@ -155,6 +185,16 @@ export class KeylessPublicKey extends AccountPublicKey {
     return new KeylessPublicKey(args.iss, computeIdCommitment(args));
   }
 
+  /**
+   * Creates a KeylessPublicKey instance from a JWT and a pepper value.
+   * This function is useful for generating a public key that can be used for authentication based on the provided JWT claims and pepper.
+   *
+   * @param args - The arguments for creating the KeylessPublicKey.
+   * @param args.jwt - The JSON Web Token to decode.
+   * @param args.pepper - The pepper value used in the key creation process.
+   * @param args.uidKey - An optional key to retrieve the unique identifier from the JWT payload, defaults to "sub".
+   * @returns A KeylessPublicKey instance created from the provided JWT and pepper.
+   */
   static fromJwtAndPepper(args: { jwt: string; pepper: HexInput; uidKey?: string }): KeylessPublicKey {
     const { jwt, pepper, uidKey = "sub" } = args;
     const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
@@ -168,6 +208,12 @@ export class KeylessPublicKey extends AccountPublicKey {
     return KeylessPublicKey.create({ iss: jwtPayload.iss, uidKey, uidVal, aud: jwtPayload.aud, pepper });
   }
 
+  /**
+   * Checks if the provided public key is a valid instance by verifying its structure and types.
+   *
+   * @param publicKey - The public key to validate.
+   * @returns A boolean indicating whether the public key is a valid instance.
+   */
   static isInstance(publicKey: PublicKey) {
     return (
       "iss" in publicKey &&
@@ -192,11 +238,11 @@ function computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string
 }
 
 /**
- * A signature of a message signed via Keyless Accounnt that uses proofs or the jwt token to authenticate.
+ * Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.
  */
 export class KeylessSignature extends Signature {
   /**
-   * The inner signature ZeroKnowledgeSigniature or OpenIdSignature
+   * The inner signature ZeroKnowledgeSignature or OpenIdSignature
    */
   readonly ephemeralCertificate: EphemeralCertificate;
 
@@ -236,15 +282,6 @@ export class KeylessSignature extends Signature {
     this.ephemeralSignature = ephemeralSignature;
   }
 
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
   serialize(serializer: Serializer): void {
     this.ephemeralCertificate.serialize(serializer);
     serializer.serializeStr(this.jwtHeader);
@@ -293,7 +330,10 @@ export class KeylessSignature extends Signature {
 }
 
 /**
- * A container for a signature that is a ZeroKnowledgeSig.  Can be expanded to support OpenIdSignature.
+ * Represents an ephemeral certificate containing a signature, specifically a ZeroKnowledgeSig.
+ * This class can be extended to support additional signature types, such as OpenIdSignature.
+ *
+ * @extends Signature
  */
 export class EphemeralCertificate extends Signature {
   public readonly signature: Signature;
@@ -334,6 +374,12 @@ export class EphemeralCertificate extends Signature {
   }
 }
 
+/**
+ * Represents a fixed-size byte array of 32 bytes, extending the Serializable class.
+ * This class is used for handling and serializing G1 bytes in cryptographic operations.
+ *
+ * @extends Serializable
+ */
 class G1Bytes extends Serializable {
   data: Uint8Array;
 
@@ -355,6 +401,12 @@ class G1Bytes extends Serializable {
   }
 }
 
+/**
+ * Represents a 64-byte G2 element in a cryptographic context.
+ * This class provides methods for serialization and deserialization of G2 bytes.
+ *
+ * @extends Serializable
+ */
 class G2Bytes extends Serializable {
   data: Uint8Array;
 
@@ -377,7 +429,10 @@ class G2Bytes extends Serializable {
 }
 
 /**
- * A representation of a Groth16 proof.  The points are the compressed serialization of affine reprentation of the proof.
+ * Represents a Groth16 zero-knowledge proof, consisting of three proof points in compressed serialization format.
+ * The points are the compressed serialization of affine representation of the proof.
+ *
+ * @extends Proof
  */
 export class Groth16Zkp extends Proof {
   /**
@@ -418,7 +473,9 @@ export class Groth16Zkp extends Proof {
 }
 
 /**
- * A container for a different zero knowledge proof types
+ * Represents a container for different types of zero-knowledge proofs.
+ *
+ * @extends Serializable
  */
 export class ZkProof extends Serializable {
   public readonly proof: Proof;
@@ -451,7 +508,9 @@ export class ZkProof extends Serializable {
 }
 
 /**
- * The signature representation of a proof
+ * Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.
+ *
+ * @extends Signature
  */
 export class ZeroKnowledgeSig extends Signature {
   /**
@@ -497,18 +556,10 @@ export class ZeroKnowledgeSig extends Signature {
   }
 
   /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
-  /**
-   * Return a ZeroKnowledgeSig object from its bcs serialization in bytes.
+   * Deserialize a ZeroKnowledgeSig object from its BCS serialization in bytes.
    *
-   * @returns ZeroKnowledgeSig
+   * @param bytes - The bytes representing the serialized ZeroKnowledgeSig.
+   * @returns ZeroKnowledgeSig - The deserialized ZeroKnowledgeSig object.
    */
   static fromBytes(bytes: Uint8Array): ZeroKnowledgeSig {
     return ZeroKnowledgeSig.deserialize(new Deserializer(bytes));
@@ -533,12 +584,17 @@ export class ZeroKnowledgeSig extends Signature {
 }
 
 /**
- * A class which represents the on-chain configuration for how Keyless accounts work
+ * Represents the on-chain configuration for how Keyless accounts operate.
+ *
+ * @remarks
+ * This class encapsulates the verification key and the maximum lifespan of ephemeral key pairs,
+ * which are essential for the functionality of Keyless accounts.
  */
 export class KeylessConfiguration {
   /**
    * The verification key used to verify Groth16 proofs on chain
    */
+  // TODO: Rename to verificationKey
   readonly verficationKey: Groth16VerificationKey;
 
   /**
@@ -566,7 +622,7 @@ export class KeylessConfiguration {
 }
 
 /**
- * A representation of the verification key stored on chain used to verify Groth16 proofs
+ * Represents the verification key stored on-chain used to verify Groth16 proofs.
  */
 class Groth16VerificationKey {
   // The docstrings below are borrowed from ark-groth16
@@ -611,6 +667,17 @@ class Groth16VerificationKey {
     this.gammaG2 = new G2Bytes(gammaG2);
   }
 
+  /**
+   * Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.
+   *
+   * @param res - The Groth16VerificationKeyResponse object containing the verification key data.
+   * @param res.alpha_g1 - The alpha G1 value from the response.
+   * @param res.beta_g2 - The beta G2 value from the response.
+   * @param res.delta_g2 - The delta G2 value from the response.
+   * @param res.gamma_abc_g1 - The gamma ABC G1 value from the response.
+   * @param res.gamma_g2 - The gamma G2 value from the response.
+   * @returns A Groth16VerificationKey instance constructed from the provided response data.
+   */
   static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {
     return new Groth16VerificationKey({
       alphaG1: res.alpha_g1,
@@ -623,10 +690,14 @@ class Groth16VerificationKey {
 }
 
 /**
- * Gets the parameters of how Keyless Accounts are configured on chain including the verifying key and the max expiry horizon
+ * Retrieves the configuration parameters for Keyless Accounts on the blockchain, including the verifying key and the maximum
+ * expiry horizon.
  *
- * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
- * @returns KeylessConfiguration
+ * @param args - The arguments for retrieving the keyless configuration.
+ * @param args.aptosConfig - The Aptos configuration object containing network details.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, the latest version will be used.
+ * @returns KeylessConfiguration - The configuration object containing the verifying key and maximum expiry horizon.
  */
 export async function getKeylessConfig(args: {
   aptosConfig: AptosConfig;
@@ -645,10 +716,13 @@ export async function getKeylessConfig(args: {
 }
 
 /**
- * Gets the KeylessConfiguration set on chain
+ * Retrieves the KeylessConfiguration set on chain.
  *
- * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
- * @returns KeylessConfigurationResponse
+ * @param args - The arguments for retrieving the configuration.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos network.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+ * @returns KeylessConfigurationResponse - The response containing the keyless configuration data.
  */
 async function getKeylessConfigurationResource(args: {
   aptosConfig: AptosConfig;
@@ -667,10 +741,13 @@ async function getKeylessConfigurationResource(args: {
 }
 
 /**
- * Gets the Groth16VerificationKey set on chain
+ * Retrieves the Groth16VerificationKey set on the blockchain.
  *
- * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
- * @returns Groth16VerificationKeyResponse
+ * @param args - The arguments for retrieving the verification key.
+ * @param args.aptosConfig - The Aptos configuration object.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+ * @returns Groth16VerificationKeyResponse - The response containing the Groth16 verification key data.
  */
 async function getGroth16VerificationKeyResource(args: {
   aptosConfig: AptosConfig;

package/src/core/crypto/multiEd25519.ts

@@ -10,6 +10,12 @@ import { Signature } from "./signature";
 
 /**
  * Represents the public key of a K-of-N Ed25519 multi-sig transaction.
+ *
+ * A K-of-N multi-sig transaction requires at least K out of N authorized signers to sign the transaction
+ * for it to be executed. This class encapsulates the logic for managing the public keys and the threshold
+ * for valid signatures.
+ *
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}
  */
 export class MultiEd25519PublicKey extends AccountPublicKey {
   /**
@@ -44,7 +50,7 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
    *
    * @see {@link
    * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}
-   *
+   * @param args - A wrapper to let you choose the param order.
    * @param args.publicKeys A list of public keys
    * @param args.threshold At least "threshold" signatures must be valid
    */
@@ -73,6 +79,16 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
 
   // region AccountPublicKey
 
+  /**
+   * Verifies a multi-signature against a given message.
+   * This function ensures that the provided signatures meet the required threshold and are valid for the given message.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The multi-signature containing multiple signatures and a bitmap indicating which signatures are valid.
+   * @returns True if the signature is valid; otherwise, false.
+   * @throws Error if the bitmap and signatures length mismatch or if there are not enough valid signatures.
+   */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
     if (!(signature instanceof MultiEd25519Signature)) {
@@ -108,6 +124,12 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
     return true;
   }
 
+  /**
+   * Generates an authentication key based on the current instance's byte representation.
+   * This function is essential for creating a secure authentication key that can be used for various cryptographic operations.
+   *
+   * @returns {AuthenticationKey} The generated authentication key.
+   */
   authKey(): AuthenticationKey {
     return AuthenticationKey.fromSchemeAndBytes({
       scheme: AuthenticationKeyScheme.MultiEd25519,
@@ -133,10 +155,22 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
 
   // region Serializable
 
+  /**
+   * Serializes the current instance into bytes using the provided serializer.
+   * This allows for the conversion of the instance's data into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer used to convert the instance into bytes.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.toUint8Array());
   }
 
+  /**
+   * Deserializes a MultiEd25519Signature from the provided deserializer.
+   * This function helps in reconstructing a MultiEd25519Signature object from its serialized byte representation.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): MultiEd25519PublicKey {
     const bytes = deserializer.deserializeBytes();
     const threshold = bytes[bytes.length - 1];
@@ -155,6 +189,8 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
 
 /**
  * Represents the signature of a K-of-N Ed25519 multi-sig transaction.
+ *
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
  */
 export class MultiEd25519Signature extends Signature {
   /**
@@ -252,9 +288,12 @@ export class MultiEd25519Signature extends Signature {
   // endregion
 
   /**
-   * Helper method to create a bitmap out of the specified bit positions
-   * @param args.bits The bitmap positions that should be set. A position starts at index 0.
-   * Valid position should range between 0 and 31.
+   * Helper method to create a bitmap out of the specified bit positions.
+   * This function allows you to set specific bits in a 32-bit long bitmap based on the provided positions.
+   *
+   * @param args The arguments for creating the bitmap.
+   * @param args.bits The bitmap positions that should be set. A position starts at index 0. Valid positions should range between 0 and 31.
+   *
    * @example
    * Here's an example of valid `bits`
    * ```
@@ -263,7 +302,7 @@ export class MultiEd25519Signature extends Signature {
    * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
    * The result bitmap should be 0b1010000000000000000000000000001
    *
-   * @returns bitmap that is 32bit long
+   * @returns bitmap that is 32 bits long.
    */
   static createBitmap(args: { bits: number[] }): Uint8Array {
     const { bits } = args;

package/src/core/crypto/multiKey.ts

@@ -6,22 +6,28 @@ import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 import { AnyPublicKey, AnySignature } from "./singleKey";
 
+/**
+ * Counts the number of set bits (1s) in a byte.
+ * This function can help you determine the population count of a given byte value.
+ *
+ * @param byte - The byte value for which to count the number of set bits.
+ */
 /* eslint-disable no-bitwise */
-
 function bitCount(byte: number) {
   let n = byte;
   n -= (n >> 1) & 0x55555555;
   n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
   return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
 }
-
 /* eslint-enable no-bitwise */
 
 /**
- * Represents the public key of a multi-agent account.
+ * Represents a multi-key authentication scheme for accounts, allowing multiple public keys
+ * to be associated with a single account. This class enforces a minimum number of valid signatures
+ * required to authorize actions, ensuring enhanced security for multi-agent accounts.
  *
  * The public keys of each individual agent can be any type of public key supported by Aptos.
- * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263), Aptos supports
  * `Legacy` and `Unified` authentication keys.
  */
 export class MultiKey extends AccountPublicKey {
@@ -35,8 +41,19 @@ export class MultiKey extends AccountPublicKey {
    */
   public readonly signaturesRequired: number;
 
+  /**
+   * Signature for a K-of-N multi-sig transaction.
+   * This constructor initializes a multi-signature transaction with the provided signatures and bitmap.
+   *
+   * @param args An object containing the parameters for the multi-signature transaction.
+   * @param args.signatures A list of signatures.
+   * @param args.bitmap A bitmap represented as a Uint8Array or an array of numbers, where each bit indicates whether a
+   * corresponding signature is present. A maximum of 32 signatures is supported, and the length of the bitmap must be 4 bytes.
+   *
+   * @throws Error if the number of signatures exceeds the maximum supported, if the bitmap length is incorrect, or if the number
+   * of signatures does not match the bitmap.
+   */
   // region Constructors
-
   constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {
     super();
     const { publicKeys, signaturesRequired } = args;
@@ -65,11 +82,25 @@ export class MultiKey extends AccountPublicKey {
 
   // region AccountPublicKey
 
+  /**
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by checking if the signature is valid.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify.
+   */
   // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
   verifySignature(args: VerifySignatureArgs): boolean {
     throw new Error("not implemented");
   }
 
+  /**
+   * Generates an authentication key based on the current instance's byte representation.
+   * This key can be used for secure authentication processes within the system.
+   *
+   * @returns {AuthenticationKey} The generated authentication key.
+   */
   authKey(): AuthenticationKey {
     return AuthenticationKey.fromSchemeAndBytes({
       scheme: AuthenticationKeyScheme.MultiKey,
@@ -77,19 +108,27 @@ export class MultiKey extends AccountPublicKey {
     });
   }
 
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
   // endregion
 
   // region Serializable
 
+  /**
+   * Serializes the object by writing its signatures and bitmap to the provided serializer.
+   * This allows the object to be converted into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeVector(this.publicKeys);
     serializer.serializeU8(this.signaturesRequired);
   }
 
+  /**
+   * Deserializes a MultiKeySignature from the provided deserializer.
+   * This function retrieves the signatures and bitmap necessary for creating a MultiKeySignature object.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): MultiKey {
     const keys = deserializer.deserializeVector(AnyPublicKey);
     const signaturesRequired = deserializer.deserializeU8();
@@ -143,8 +182,12 @@ export class MultiKey extends AccountPublicKey {
   /**
    * Get the index of the provided public key.
    *
-   * @param publicKey array of the index mapping to the matching public keys
-   * @returns the corresponding index of the publicKey, if it exists
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
    */
   getIndex(publicKey: PublicKey): number {
     const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
@@ -155,8 +198,20 @@ export class MultiKey extends AccountPublicKey {
     }
     throw new Error("Public key not found in MultiKey");
   }
+
+  public static isInstance(value: PublicKey): value is MultiKey {
+    return "publicKeys" in value && "signaturesRequired" in value;
+  }
 }
 
+/**
+ * Represents a multi-signature transaction using Ed25519 signatures.
+ * This class allows for the creation and management of a K-of-N multi-signature scheme,
+ * where a specified number of signatures are required to authorize a transaction.
+ *
+ * It includes functionality to validate the number of signatures against a bitmap,
+ * which indicates which public keys have signed the transaction.
+ */
 export class MultiKeySignature extends Signature {
   /**
    * Number of bytes in the bitmap representing who signed the transaction (32-bits)
@@ -265,14 +320,6 @@ export class MultiKeySignature extends Signature {
     return bitmap;
   }
 
-  // region Signature
-
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
-  // endregion
-
   // region Serializable
 
   serialize(serializer: Serializer): void {