@aptos-labs/ts-sdk 1.29.1 → 1.31.0

package/src/account/Account.ts

@@ -9,8 +9,11 @@ import { AnyRawTransaction } from "../transactions/types";
 
 /**
  * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
- * This is the default input type when passing an `Ed25519PrivateKey`.
- * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
+ * To use the SingleKey authentication scheme, set `legacy` to false.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address for the account.
+ * @param legacy - Indicates whether to use legacy authentication (default is true).
  */
 export interface CreateEd25519AccountFromPrivateKeyArgs {
   privateKey: Ed25519PrivateKey;
@@ -19,9 +22,12 @@ export interface CreateEd25519AccountFromPrivateKeyArgs {
 }
 
 /**
- * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false in order to
- * use the `SingleKey` authentication scheme.
+ * Arguments for creating a `SingleKeyAccount` using an `Ed25519PrivateKey`.
+ * The `legacy` property must be set to false to utilize the `SingleKey` authentication scheme.
+ *
+ * @param privateKey - The Ed25519 private key used for account creation.
+ * @param address - Optional account address input.
+ * @param legacy - Must be false to enable the `SingleKey` authentication scheme.
  */
 export interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
   privateKey: Ed25519PrivateKey;
@@ -30,9 +36,12 @@ export interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
 }
 
 /**
- * Arguments for creating an `SingleKeyAccount` from any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ * Arguments for creating a `SingleKeyAccount` from a supported private key, excluding `Ed25519PrivateKey`.
+ * The `legacy` argument is always false and cannot be set to true.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address input for the account.
+ * @param legacy - Always false; cannot be explicitly set to true.
  */
 export interface CreateSingleKeyAccountFromPrivateKeyArgs {
   privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
@@ -41,8 +50,11 @@ export interface CreateSingleKeyAccountFromPrivateKeyArgs {
 }
 
 /**
- * Arguments for creating an opaque `Account` from any supported private key.
- * This is used when the private key type is not known at compilation time.
+ * Arguments for creating an `Account` from a private key when the key type is unknown at compile time.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address for the account.
+ * @param legacy - Optional flag indicating if the account is a legacy account.
  */
 export interface CreateAccountFromPrivateKeyArgs {
   privateKey: PrivateKey;
@@ -51,8 +63,10 @@ export interface CreateAccountFromPrivateKeyArgs {
 }
 
 /**
- * Arguments for generating an `Ed25519Account`.
- * This is the input type used by default.
+ * Arguments for generating an Ed25519 account, specifying the signing scheme and legacy option.
+ *
+ * @param scheme - The signing scheme to use for the account.
+ * @param legacy - Indicates if the account should be created in legacy mode.
  */
 export interface GenerateEd25519AccountArgs {
   scheme?: SigningSchemeInput.Ed25519;
@@ -60,9 +74,11 @@ export interface GenerateEd25519AccountArgs {
 }
 
 /**
- * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false,
- * otherwise an `Ed25519Account` will be returned instead.
+ * Arguments for generating a `SingleKeyAccount` with an underlying `Ed25519PrivateKey`.
+ * The `legacy` argument must be set to false to ensure an `Ed25519SingleKeyAccount` is returned.
+ *
+ * @param scheme - Optional signing scheme input for the account.
+ * @param legacy - Indicates whether to use legacy account generation.
  */
 export interface GenerateEd25519SingleKeyAccountArgs {
   scheme?: SigningSchemeInput.Ed25519;
@@ -70,9 +86,11 @@ export interface GenerateEd25519SingleKeyAccountArgs {
 }
 
 /**
- * Arguments for generating an `SingleKeyAccount` with any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ * Arguments for generating a `SingleKeyAccount` using a supported private key other than `Ed25519PrivateKey`.
+ * The `legacy` argument is optional and defaults to false, and cannot be set to true.
+ *
+ * @param scheme - The signing scheme to use for the account.
+ * @param legacy - Indicates whether to use legacy account generation (defaults to false).
  */
 export interface GenerateSingleKeyAccountArgs {
   scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
@@ -80,8 +98,10 @@ export interface GenerateSingleKeyAccountArgs {
 }
 
 /**
- * Arguments for generating an opaque `Account`.
- * This is used when the input signature scheme is not known at compilation time.
+ * Arguments for generating an opaque `Account` when the input signature scheme is unknown at compile time.
+ *
+ * @param scheme - The signing scheme to use for account generation.
+ * @param legacy - Indicates whether to use legacy account generation methods.
  */
 export interface GenerateAccountArgs {
   scheme?: SigningSchemeInput;
@@ -89,7 +109,10 @@ export interface GenerateAccountArgs {
 }
 
 /**
- * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
+ * Arguments for deriving a private key using a mnemonic phrase and a specified BIP44 path.
+ *
+ * @param path - The BIP44 derivation path for the key.
+ * @param mnemonic - The mnemonic phrase used for key generation.
  */
 export interface PrivateKeyFromDerivationPathArgs {
   path: string;
@@ -97,12 +120,11 @@ export interface PrivateKeyFromDerivationPathArgs {
 }
 
 /**
- * Interface for a generic Aptos account.
+ * Abstract class representing a generic Aptos account.
  *
- * The interface is defined as abstract class to provide a single entrypoint for account generation,
- * either through `Account.generate()` or `Account.fromDerivationPath`.
- * Despite this being an abstract class, it should be treated as an interface and enforced using
- * the `implements` keyword.
+ * This class serves as a single entry point for account generation, allowing accounts to be created
+ * either through `Account.generate()` or `Account.fromDerivationPath`. Although it is defined as an
+ * abstract class, it should be treated as an interface and enforced using the `implements` keyword.
  *
  * Note: Generating an account instance does not create the account on-chain.
  */
@@ -123,10 +145,12 @@ export abstract class Account {
   abstract signingScheme: SigningScheme;
 
   /**
-   * Derives an account from a randomly generated private key.
-   * @param args.scheme The signature scheme to use, to generate the private key
-   * @param args.legacy Whether to use a legacy authentication scheme, when applicable
-   * @returns An account compatible with the provided signature scheme
+   * Generates a new account based on the specified signing scheme and legacy option.
+   * This function allows you to create an account with either the Ed25519 signing scheme or a different scheme as specified.
+   *
+   * @param args - The arguments for generating the account.
+   * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.
+   * @param args.legacy - Indicates whether to use the legacy account generation method. Defaults to true.
    */
   static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
   static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
@@ -141,11 +165,15 @@ export abstract class Account {
   }
 
   /**
-   * Creates an account from the provided private key.
+   * Creates an account from a given private key and address.
+   * This function allows you to instantiate an account based on the provided private key,
+   * and it can differentiate between legacy and non-legacy accounts.
    *
-   * @param args.privateKey a valid private key
-   * @param args.address the account's address. If not provided, it will be derived from the public key.
-   * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+   * @param args - The arguments for creating the account.
+   * @param args.privateKey - The private key used to create the account.
+   * @param args.address - The address associated with the account.
+   * @param args.legacy - A boolean indicating whether to create a legacy account (default is true).
+   * @returns An instance of either Ed25519Account or SingleKeyAccount based on the provided private key.
    */
   static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
   static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
@@ -164,13 +192,14 @@ export abstract class Account {
 
   /**
    * @deprecated use `fromPrivateKey` instead.
-   * Instantiates an account given a private key and a specified account address.
-   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
+   * Instantiates an account using a private key and a specified account address. This is primarily used to instantiate an
+   * `Account` that has had its authentication key rotated.
    *
-   * @param args.privateKey PrivateKey - the underlying private key for the account
-   * @param args.address AccountAddress - The account address the `Account` will sign for
-   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-   * to generating a Legacy Ed25519 keypair
+   * @param args - The arguments required to create an account from a private key.
+   * @param args.privateKey - The underlying private key for the account.
+   * @param args.address - The account address the `Account` will sign for.
+   * @param args.legacy - Optional. If set to false, the keypair generated is a Unified keypair. Defaults to generating a Legacy
+   * Ed25519 keypair.
    *
    * @returns Account
    */
@@ -179,13 +208,14 @@ export abstract class Account {
   }
 
   /**
-   * Derives an account with bip44 path and mnemonics
+   * Generates an account from a specified derivation path and mnemonic.
+   * This function allows you to create an account using different signing schemes based on the provided arguments.
    *
-   * @param args.scheme The signature scheme to derive the private key with
-   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-   * @param args.mnemonic the mnemonic seed phrase of the account
+   * @param args - The arguments for generating the account.
+   * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.
+   * @param args.mnemonic - The mnemonic phrase used to derive the account.
+   * @param args.path - The derivation path used to generate the account.
+   * @param args.legacy - A boolean indicating whether to use the legacy account generation method. Defaults to true.
    */
   static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
   static fromDerivationPath(
@@ -202,13 +232,14 @@ export abstract class Account {
   }
 
   /**
-   * @deprecated use `publicKey.authKey()` instead.
-   * This key enables account owners to rotate their private key(s)
-   * associated with the account without changing the address that hosts their account.
+   * Retrieve the authentication key for the associated account using the provided public key.
+   * This key enables account owners to rotate their private key(s) associated with the account without changing the address that
+   * hosts their account.
    * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
    *
-   * @param args.publicKey PublicKey - public key of the account
-   * @returns The authentication key for the associated account
+   * @param args - The arguments for retrieving the authentication key.
+   * @param args.publicKey - The public key of the account.
+   * @returns The authentication key for the associated account.
    */
   static authKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {
     const { publicKey } = args;
@@ -245,9 +276,12 @@ export abstract class Account {
 
   /**
    * Verify the given message and signature with the public key.
-   * @param args.message raw message data in HexInput format
-   * @param args.signature signed message Signature
-   * @returns
+   * This function helps ensure the integrity and authenticity of a message by validating its signature.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The raw message data in HexInput format.
+   * @param args.signature - The signed message signature.
+   * @returns A boolean indicating whether the signature is valid.
    */
   verifySignature(args: VerifySignatureArgs): boolean {
     return this.publicKey.verifySignature(args);

package/src/account/Ed25519Account.ts

@@ -6,26 +6,44 @@ import type { Account } from "./Account";
 import { AnyRawTransaction } from "../transactions/types";
 import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
 
+/**
+ * Arguments required to create an instance of an Ed25519 signer.
+ *
+ * @param privateKey - The private key used for signing.
+ * @param address - Optional account address associated with the signer.
+ */
 export interface Ed25519SignerConstructorArgs {
   privateKey: Ed25519PrivateKey;
   address?: AccountAddressInput;
 }
 
+/**
+ * Arguments for creating an Ed25519 signer from a derivation path.
+ *
+ * @param path - The derivation path for the Ed25519 key.
+ * @param mnemonic - The mnemonic phrase used to generate the key.
+ */
 export interface Ed25519SignerFromDerivationPathArgs {
   path: string;
   mnemonic: string;
 }
 
+/**
+ * Arguments required to verify an Ed25519 signature against a given message.
+ *
+ * @param message - The message to be verified, represented in hexadecimal format.
+ * @param signature - The Ed25519 signature to validate.
+ */
 export interface VerifyEd25519SignatureArgs {
   message: HexInput;
   signature: Ed25519Signature;
 }
 
 /**
- * Signer implementation for the Ed25519 authentication scheme.
- * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
+ * Represents an Ed25519 account that provides signing capabilities through an Ed25519 private key.
+ * This class allows for the creation of accounts, signing messages and transactions, and verifying signatures.
  *
- * Note: Generating a signer instance does not create the account on-chain.
+ * Note: Generating an instance of this class does not create the account on-chain.
  */
 export class Ed25519Account implements Account {
   /**
@@ -41,6 +59,14 @@ export class Ed25519Account implements Account {
 
   // region Constructors
 
+  /**
+   * Creates an instance of the Ed25519Signer with the specified parameters.
+   * This constructor initializes the private key, public key, and account address for the signer.
+   *
+   * @param args - The constructor arguments for the Ed25519Signer.
+   * @param args.privateKey - The private key used for signing.
+   * @param args.address - The optional account address; if not provided, it will derive the address from the public key.
+   */
   constructor(args: Ed25519SignerConstructorArgs) {
     const { privateKey, address } = args;
     this.privateKey = privateKey;
@@ -49,36 +75,39 @@ export class Ed25519Account implements Account {
   }
 
   /**
-   * Derives a signer from a randomly generated private key
+   * Generates a new Ed25519 account using a randomly generated private key.
+   * This function is useful for creating a signer that can be used for cryptographic operations.
+   *
+   * @returns {Ed25519Account} The newly generated Ed25519 account.
    */
-  static generate() {
+  static generate(): Ed25519Account {
     const privateKey = Ed25519PrivateKey.generate();
     return new Ed25519Account({ privateKey });
   }
 
   /**
-   * Derives an account with bip44 path and mnemonics
+   * Derives an Ed25519 account using a specified BIP44 path and mnemonic seed phrase.
    *
-   * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
+   * @param args - The arguments for deriving the account.
+   * @param args.path - The BIP44 derive hardened path, e.g., m/44'/637'/0'/0'/0'.
    * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-   * @param args.mnemonic the mnemonic seed phrase of the account
+   * @param args.mnemonic - The mnemonic seed phrase of the account.
    */
   static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs) {
     const { path, mnemonic } = args;
     const privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
     return new Ed25519Account({ privateKey });
   }
-
   // endregion
 
   // region Account
-
   /**
    * Verify the given message and signature with the public key.
    *
-   * @param args.message raw message data in HexInput format
-   * @param args.signature signed message Signature
-   * @returns
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - Raw message data in HexInput format.
+   * @param args.signature - Signed message signature.
+   * @returns A boolean indicating whether the signature is valid.
    */
   verifySignature(args: VerifyEd25519SignatureArgs): boolean {
     return this.publicKey.verifySignature(args);
@@ -86,8 +115,10 @@ export class Ed25519Account implements Account {
 
   /**
    * Sign a message using the account's Ed25519 private key.
-   * @param message the signing message, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   * This function returns an AccountAuthenticator containing the signature along with the account's public key.
+   *
+   * @param message - The signing message, represented as hexadecimal input.
+   * @returns An AccountAuthenticator containing the signature and the account's public key.
    */
   signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519 {
     return new AccountAuthenticatorEd25519(this.publicKey, this.privateKey.sign(message));
@@ -95,8 +126,10 @@ export class Ed25519Account implements Account {
 
   /**
    * Sign a transaction using the account's Ed25519 private key.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   * This function returns an AccountAuthenticator that contains the signature of the transaction along with the account's public key.
+   *
+   * @param transaction - The raw transaction to be signed.
+   * @returns An AccountAuthenticator containing the signature and the public key.
    */
   signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorEd25519 {
     return new AccountAuthenticatorEd25519(this.publicKey, this.signTransaction(transaction));
@@ -104,8 +137,8 @@ export class Ed25519Account implements Account {
 
   /**
    * Sign the given message using the account's Ed25519 private key.
-   * @param message in HexInput format
-   * @returns Signature
+   * @param message - The message to be signed in HexInput format.
+   * @returns Signature - The resulting signature of the signed message.
    */
   sign(message: HexInput): Ed25519Signature {
     return this.privateKey.sign(message);
@@ -113,8 +146,10 @@ export class Ed25519Account implements Account {
 
   /**
    * Sign the given transaction using the available signing capabilities.
-   * @param transaction the transaction to be signed
-   * @returns Signature
+   * This function helps ensure that the transaction is properly authenticated before submission.
+   *
+   * @param transaction - The transaction to be signed.
+   * @returns Signature - The resulting signature for the transaction.
    */
   signTransaction(transaction: AnyRawTransaction): Ed25519Signature {
     return this.sign(generateSigningMessageForTransaction(transaction));

package/src/account/EphemeralKeyPair.ts

@@ -20,8 +20,9 @@ import { floorToWholeHour, nowInSeconds } from "../utils/helpers";
 const TWO_WEEKS_IN_SECONDS = 1_209_600;
 
 /**
- * A class which contains a key pair that is used in signing transactions via the Keyless authentication scheme. This key pair
- * is ephemeral and has an expiration time.  For more details on how this class is used -
+ * Represents an ephemeral key pair used for signing transactions via the Keyless authentication scheme.
+ * This key pair is temporary and includes an expiration time.
+ * For more details on how this class is used, refer to the documentation:
  * https://aptos.dev/guides/keyless-accounts/#1-present-the-user-with-a-sign-in-with-idp-button-on-the-ui
  */
 export class EphemeralKeyPair extends Serializable {
@@ -40,8 +41,8 @@ export class EphemeralKeyPair extends Serializable {
   readonly expiryDateSecs: number;
 
   /**
-   * The value passed to the IdP when the user authenticates.  It comprises of a hash of the
-   * ephermeral public key, expiry date, and blinder.
+   * The value passed to the IdP when the user authenticates.  It consists of a hash of the
+   * ephemeral public key, expiry date, and blinder.
    */
   readonly nonce: string;
 
@@ -57,6 +58,16 @@ export class EphemeralKeyPair extends Serializable {
    */
   private publicKey: EphemeralPublicKey;
 
+  /**
+   * Creates an instance of the class with a specified private key, optional expiry date, and optional blinder.
+   * This constructor initializes the public key, sets the expiry date to a default value if not provided,
+   * generates a blinder if not supplied, and calculates the nonce based on the public key, expiry date, and blinder.
+   *
+   * @param args - The parameters for constructing the instance.
+   * @param args.privateKey - The private key used for creating the instance.
+   * @param args.expiryDateSecs - Optional expiry date in seconds from the current time. Defaults to two weeks from now.
+   * @param args.blinder - Optional blinder value. If not provided, a new blinder will be generated.
+   */
   constructor(args: { privateKey: PrivateKey; expiryDateSecs?: number; blinder?: HexInput }) {
     super();
     const { privateKey, expiryDateSecs, blinder } = args;
@@ -83,14 +94,20 @@ export class EphemeralKeyPair extends Serializable {
   }
 
   /**
-   * Returns the public key of the key pair.
-   * @return boolean
+   * Checks if the current time has surpassed the expiry date of the key pair.
+   * @return boolean - Returns true if the key pair is expired, otherwise false.
    */
   isExpired(): boolean {
     const currentTimeSecs: number = Math.floor(Date.now() / 1000);
     return currentTimeSecs > this.expiryDateSecs;
   }
 
+  /**
+   * Serializes the object's properties into a format suitable for transmission or storage.
+   * This function is essential for preparing the object data for serialization processes.
+   *
+   * @param serializer - The serializer instance used to serialize the object's properties.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(this.publicKey.variant);
     serializer.serializeBytes(this.privateKey.toUint8Array());
@@ -98,6 +115,12 @@ export class EphemeralKeyPair extends Serializable {
     serializer.serializeFixedBytes(this.blinder);
   }
 
+  /**
+   * Deserializes an ephemeral key pair from the provided deserializer.
+   * This function helps in reconstructing an ephemeral key pair, which is essential for cryptographic operations.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): EphemeralKeyPair {
     const variantIndex = deserializer.deserializeUleb128AsU32();
     let privateKey: PrivateKey;
@@ -113,15 +136,24 @@ export class EphemeralKeyPair extends Serializable {
     return new EphemeralKeyPair({ privateKey, expiryDateSecs: Number(expiryDateSecs), blinder });
   }
 
+  /**
+   * Deserialize a byte array into an EphemeralKeyPair object.
+   * This function allows you to reconstruct an EphemeralKeyPair from its serialized byte representation.
+   *
+   * @param bytes - The byte array representing the serialized EphemeralKeyPair.
+   */
   static fromBytes(bytes: Uint8Array): EphemeralKeyPair {
     return EphemeralKeyPair.deserialize(new Deserializer(bytes));
   }
 
   /**
-   * Returns the public key of the key pair.
-   * @param scheme the type of keypair to use for the EphemeralKeyPair.  Only Ed25519 supported for now.
-   * @param expiryDateSecs the date of expiry.
-   * @return boolean
+   * Generates a new ephemeral key pair with an optional expiry date.
+   * This function allows you to create a temporary key pair for secure operations.
+   *
+   * @param args - Optional parameters for key pair generation.
+   * @param args.scheme - The type of key pair to use for the EphemeralKeyPair. Only Ed25519 is supported for now.
+   * @param args.expiryDateSecs - The date of expiry for the key pair in seconds.
+   * @returns An instance of EphemeralKeyPair containing the generated private key and expiry date.
    */
   static generate(args?: { scheme?: EphemeralPublicKeyVariant; expiryDateSecs?: number }): EphemeralKeyPair {
     let privateKey: PrivateKey;
@@ -136,9 +168,12 @@ export class EphemeralKeyPair extends Serializable {
   }
 
   /**
-   * Sign the given message with the private key.
-   * @param data in HexInput format
-   * @returns EphemeralSignature
+   * Sign the given data using the private key, returning an ephemeral signature.
+   * This function is essential for creating a secure signature that can be used for authentication or verification purposes.
+   *
+   * @param data - The data to be signed, provided in HexInput format.
+   * @returns EphemeralSignature - The resulting ephemeral signature.
+   * @throws Error - Throws an error if the EphemeralKeyPair has expired.
    */
   sign(data: HexInput): EphemeralSignature {
     if (this.isExpired()) {
@@ -149,8 +184,8 @@ export class EphemeralKeyPair extends Serializable {
 }
 
 /**
- * Generates a random byte array of length EphemeralKeyPair.BLINDER_LENGTH
- * @returns Uint8Array
+ * Generates a random byte array of length EphemeralKeyPair.BLINDER_LENGTH.
+ * @returns Uint8Array A random byte array used for blinding.
  */
 function generateBlinder(): Uint8Array {
   return randomBytes(EphemeralKeyPair.BLINDER_LENGTH);

package/src/account/FederatedKeylessAccount.ts

@@ -16,7 +16,7 @@ import { AbstractKeylessAccount, ProofFetchCallback } from "./AbstractKeylessAcc
  *
  * Used to represent a FederatedKeyless based account and sign transactions with it.
  *
- * Use FederatedKeylessAccount.create to instantiate a KeylessAccount with a JWT, proof, EphemeralKeyPair and the
+ * Use `FederatedKeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof, EphemeralKeyPair and the
  * address the JWKs are installed that will be used to verify the JWT.
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,

package/src/account/KeylessAccount.ts

@@ -15,10 +15,13 @@ import { AbstractKeylessAccount, ProofFetchCallback } from "./AbstractKeylessAcc
  *
  * Used to represent a Keyless based account and sign transactions with it.
  *
- * Use KeylessAccount.create to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
+ * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
  * EphemeralKeyPair, and corresponding proof.
+ *
+ * @static
+ * @readonly PEPPER_LENGTH - The length of the pepper used for privacy preservation.
  */
 export class KeylessAccount extends AbstractKeylessAccount {
   /**
@@ -27,6 +30,13 @@ export class KeylessAccount extends AbstractKeylessAccount {
   readonly publicKey: KeylessPublicKey;
 
   // Use the static constructor 'create' instead.
+
+  /**
+   * Creates an instance of the transaction with an optional proof.
+   *
+   * @param args.proof - An optional ZkProof associated with the transaction.
+   */
+  // TODO: Document rest of parameters
   private constructor(args: {
     address?: AccountAddress;
     ephemeralKeyPair: EphemeralKeyPair;
@@ -44,6 +54,12 @@ export class KeylessAccount extends AbstractKeylessAccount {
     this.publicKey = publicKey;
   }
 
+  /**
+   * Serializes the transaction data into a format suitable for transmission or storage.
+   * This function ensures that both the transaction bytes and the proof are properly serialized.
+   *
+   * @param serializer - The serializer instance used to convert the transaction data into bytes.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeStr(this.jwt);
     serializer.serializeStr(this.uidKey);
@@ -55,6 +71,13 @@ export class KeylessAccount extends AbstractKeylessAccount {
     this.proof.serialize(serializer);
   }
 
+  /**
+   * Deserializes the provided deserializer to create a KeylessAccount instance.
+   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+   *
+   * @param deserializer - The deserializer instance used to retrieve the serialized data.
+   * @returns A KeylessAccount instance created from the deserialized data.
+   */
   static deserialize(deserializer: Deserializer): KeylessAccount {
     const jwt = deserializer.deserializeStr();
     const uidKey = deserializer.deserializeStr();
@@ -74,6 +97,19 @@ export class KeylessAccount extends AbstractKeylessAccount {
     return KeylessAccount.deserialize(new Deserializer(bytes));
   }
 
+  /**
+   * Creates a KeylessAccount instance using the provided parameters.
+   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @param args.uidKey - Optional key for user identification, defaults to "sub".
+   * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   */
   static create(args: {
     address?: AccountAddress;
     proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;