@stellar/typescript-wallet-sdk 1.2.0 → 1.3.0

package/src/walletSdk/Customer/index.ts

@@ -0,0 +1,174 @@
+import { AxiosInstance } from "axios";
+import queryString from "query-string";
+import { Sep9InfoRequiredError, CustomerNotFoundError } from "../Exceptions";
+import {
+  CustomerInfoMap,
+  GetCustomerParams,
+  GetCustomerResponse,
+  AddCustomerResponse,
+  AddCustomerParams,
+  AuthToken,
+} from "../Types";
+
+/**
+ * KYC management with Sep-12.
+ * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0012.md}
+ * Do not create this object directly, use the Anchor class.
+ * @class
+ */
+export class Sep12 {
+  private authToken;
+  private baseUrl;
+  private httpClient;
+  private headers;
+
+  /**
+   * Creates a new instance of the Sep12 class.
+   * @constructor
+   * @param {AuthToken} authToken - The authentication token for authenticating with the server.
+   * @param {string} baseUrl - The KYC url.
+   * @param {AxiosInstance} httpClient - An Axios instance for making HTTP requests.
+   */
+  constructor(
+    authToken: AuthToken,
+    baseUrl: string,
+    httpClient: AxiosInstance,
+  ) {
+    this.authToken = authToken;
+    this.baseUrl = baseUrl;
+    this.httpClient = httpClient;
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.authToken.token}`,
+    };
+  }
+
+  /**
+   * Retrieve customer information. All arguments are optional, but at least one
+   * must be given. For more information:
+   * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0012.md#request}
+   * @param {object} params - The parameters for retrieving customer information.
+   * @param {string} [params.id] - The id of the customer .
+   * @param {string} [params.type] - The type of action the customer is being KYCd for.
+   * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0012.md#type-specification}
+   * @param {string} [params.memo] - A memo associated with the customer.
+   * @param {string} [params.lang] - The desired language. Defaults to "en".
+   * @returns {Promise<GetCustomerResponse>} The customer information.
+   * @throws {CustomerNotFoundError} If the customer is not found.
+   */
+  async getCustomer(params: GetCustomerParams): Promise<GetCustomerResponse> {
+    const qs = queryString.stringify(params);
+    const resp = await this.httpClient.get(`${this.baseUrl}/customer?${qs}`, {
+      headers: this.headers,
+    });
+    if (!resp.data.id) {
+      throw new CustomerNotFoundError(params);
+    }
+    return resp;
+  }
+
+  /**
+   * Add a new customer. Customer info is given in sep9Info param. If it
+   * is binary type (eg. Buffer of an image) include it in sep9BinaryInfo.
+   * @param {AddCustomerParams} params - The parameters for adding a customer.
+   * @param {CustomerInfoMap} [params.sep9Info] - Customer information. What fields you should
+   * give is indicated by the anchor.
+   * @param {CustomerInfoMap} [params.sep9BinaryInfo] - Customer information that is in binary
+   * format (eg. Buffer of an image).
+   * @param {string} [params.type] - The type of the customer.
+   * @param {string} [params.memo] - A memo associated with the customer.
+   * @returns {Promise<AddCustomerResponse>} Add customer response.
+   */
+  async add({
+    sep9Info,
+    sep9BinaryInfo,
+    type,
+    memo,
+  }: AddCustomerParams): Promise<AddCustomerResponse> {
+    let customerMap: CustomerInfoMap = { ...sep9Info, ...sep9BinaryInfo };
+    if (type) {
+      customerMap = { type, ...customerMap };
+    }
+    if (memo) {
+      customerMap["memo"] = memo;
+    }
+
+    // Check if binary data given so can adjust headers
+    const includesBinary = sep9BinaryInfo && Object.keys(sep9BinaryInfo).length;
+    const resp = await this.httpClient.put(
+      `${this.baseUrl}/customer`,
+      customerMap,
+      {
+        headers: includesBinary
+          ? { ...this.headers, "Content-Type": "multipart/form-data" }
+          : this.headers,
+      },
+    );
+    return resp;
+  }
+
+  /**
+   * Updates an existing customer. Customer info is given in sep9Info param. If it
+   * is binary type (eg. Buffer of an image) include it in sep9BinaryInfo.
+   * @param {AddCustomerParams} params - The parameters for adding a customer.
+   * @param {CustomerInfoMap} [params.sep9Info] - Customer information. What fields you should
+   * give is indicated by the anchor.
+   * @param {CustomerInfoMap} [params.sep9BinaryInfo] - Customer information that is in binary
+   * format (eg. Buffer of an image).
+   * @param {string} [params.id] - The id of the customer.
+   * @param {string} [params.type] - The type of the customer.
+   * @param {string} [params.memo] - A memo associated with the customer.
+   * @returns {Promise<AddCustomerResponse>} Add customer response.
+   * @throws {Sep9InfoRequiredError} If no SEP-9 info is given.
+   */
+  async update({
+    sep9Info,
+    sep9BinaryInfo,
+    id,
+    type,
+    memo,
+  }: AddCustomerParams): Promise<AddCustomerResponse> {
+    let customerMap: CustomerInfoMap = {};
+    if (id) {
+      customerMap["id"] = id;
+    }
+    if (type) {
+      customerMap["type"] = type;
+    }
+    if (memo) {
+      customerMap["memo"] = memo;
+    }
+    if (!Object.keys({ ...sep9Info, ...sep9BinaryInfo }).length) {
+      throw new Sep9InfoRequiredError();
+    }
+    customerMap = { ...customerMap, ...sep9Info, ...sep9BinaryInfo };
+
+    // Check if binary data given so can adjust headers
+    const includesBinary = sep9BinaryInfo && Object.keys(sep9BinaryInfo).length;
+    const resp = await this.httpClient.put(
+      `${this.baseUrl}/customer`,
+      customerMap,
+      {
+        headers: includesBinary
+          ? { ...this.headers, "Content-Type": "multipart/form-data" }
+          : this.headers,
+      },
+    );
+    return resp;
+  }
+
+  /**
+   * Deletes a customer.
+   * @param {string} accountAddress - The account address of the customer to delete.
+   * @param {string} [memo] - An optional memo for customer identification.
+   */
+  async delete(accountAddress?: string, memo?: string) {
+    await this.httpClient.delete(
+      `${this.baseUrl}/customer/${accountAddress || this.authToken.account}`,
+      {
+        data: { memo },
+        headers: this.headers,
+      },
+    );
+  }
+}

package/src/walletSdk/Exceptions/index.ts

@@ -1,9 +1,28 @@
 import { Networks, Horizon } from "stellar-sdk";
-import { AnchorTransaction, FLOW_TYPE } from "../Types";
+import axios from "axios";
+import {
+  AnchorTransaction,
+  FLOW_TYPE,
+  AxiosErrorData,
+  GetCustomerParams,
+} from "../Types";
+import { extractAxiosErrorData } from "../Utils";
 
 export class ServerRequestFailedError extends Error {
+  data: AxiosErrorData;
+
   constructor(e: Error) {
-    super(`Server request failed with error: ${e}`);
+    if (axios.isAxiosError(e)) {
+      const errorData = extractAxiosErrorData(e);
+      const message =
+        errorData.responseData && Object.keys(errorData.responseData).length > 0
+          ? JSON.stringify(errorData.responseData)
+          : errorData.statusText;
+      super(`Server request failed with error: ${errorData.status} ${message}`);
+      this.data = errorData;
+    } else {
+      super(`Server request failed with error: ${e}`);
+    }
     Object.setPrototypeOf(this, ServerRequestFailedError.prototype);
   }
 }
@@ -68,8 +87,8 @@ export class AccountDoesNotExistError extends Error {
 }
 
 export class TransactionSubmitFailedError extends Error {
-  constructor(response: Horizon.SubmitTransactionResponse) {
-    super(`Submit transaction failed ${response}`);
+  constructor(response: Horizon.HorizonApi.SubmitTransactionResponse) {
+    super(`Submit transaction failed ${JSON.stringify(response)}`);
     Object.setPrototypeOf(this, TransactionSubmitFailedError.prototype);
   }
 }
@@ -153,9 +172,101 @@ export class PathPayOnlyOneAmountError extends Error {
     Object.setPrototypeOf(this, PathPayOnlyOneAmountError.prototype);
   }
 }
+
 export class WithdrawalTxMemoError extends Error {
   constructor() {
     super(`Error parsing withdrawal transaction memo`);
     Object.setPrototypeOf(this, WithdrawalTxMemoError.prototype);
   }
 }
+
+export class Sep9InfoRequiredError extends Error {
+  constructor() {
+    super(`Sep-9 info required`);
+    Object.setPrototypeOf(this, Sep9InfoRequiredError.prototype);
+  }
+}
+
+export class CustomerNotFoundError extends Error {
+  constructor(params: GetCustomerParams) {
+    super(`Customer not found using params ${JSON.stringify(params)}`);
+    Object.setPrototypeOf(this, CustomerNotFoundError.prototype);
+  }
+}
+
+export class KYCServerNotFoundError extends Error {
+  constructor() {
+    super(`Required KYC server URL not found`);
+    Object.setPrototypeOf(this, KYCServerNotFoundError.prototype);
+  }
+}
+
+export class RecoveryServerNotFoundError extends Error {
+  constructor(serverKey: string) {
+    super(`Server with key ${serverKey} was not found`);
+    Object.setPrototypeOf(this, RecoveryServerNotFoundError.prototype);
+  }
+}
+
+export class RecoveryIdentityNotFoundError extends Error {
+  constructor(serverKey: string) {
+    super(`Account identity for server ${serverKey} was not specified`);
+    Object.setPrototypeOf(this, RecoveryIdentityNotFoundError.prototype);
+  }
+}
+
+export class NotAllSignaturesFetchedError extends Error {
+  constructor() {
+    super(`Didn't get all recovery server signatures`);
+    Object.setPrototypeOf(this, NotAllSignaturesFetchedError.prototype);
+  }
+}
+
+export class LostSignerKeyNotFound extends Error {
+  constructor() {
+    super(`Lost key doesn't belong to the account`);
+    Object.setPrototypeOf(this, LostSignerKeyNotFound.prototype);
+  }
+}
+
+export class NoDeviceKeyForAccountError extends Error {
+  constructor() {
+    super(`No device key is setup for this account`);
+    Object.setPrototypeOf(this, NoDeviceKeyForAccountError.prototype);
+  }
+}
+
+export class UnableToDeduceKeyError extends Error {
+  constructor() {
+    super(`Couldn't deduce lost key. Please provide lost key explicitly`);
+    Object.setPrototypeOf(this, UnableToDeduceKeyError.prototype);
+  }
+}
+
+export class NoAccountSignersError extends Error {
+  constructor() {
+    super(`There are no signers on this recovery server`);
+    Object.setPrototypeOf(this, NoAccountSignersError.prototype);
+  }
+}
+
+export class DeviceKeyEqualsMasterKeyError extends Error {
+  constructor() {
+    super(`Device key must be different from master (account) key`);
+    Object.setPrototypeOf(this, DeviceKeyEqualsMasterKeyError.prototype);
+  }
+}
+
+export class NoAccountAndNoSponsorError extends Error {
+  constructor() {
+    super(`Account does not exist and is not sponsored`);
+    Object.setPrototypeOf(this, NoAccountAndNoSponsorError.prototype);
+  }
+}
+
+export class Sep38PriceOnlyOneAmountError extends Error {
+  constructor() {
+    super("Must give sellAmount or buyAmount value, but not both");
+    Object.setPrototypeOf(this, Sep38PriceOnlyOneAmountError.prototype);
+  }
+}

package/src/walletSdk/Horizon/AccountService.ts

@@ -1,4 +1,4 @@
-import { Keypair, Networks, Server, ServerApi } from "stellar-sdk";
+import { Keypair, Networks, Horizon } from "stellar-sdk";
 
 import { Config } from "walletSdk";
 import { SigningKeypair } from "./Account";
@@ -10,10 +10,21 @@ import {
 import { OperationsLimitExceededError } from "../Exceptions";
 
 // Do not create this object directly, use the Wallet class.
+/**
+ * KYC management with Sep-12.
+ * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0012.md}
+ * Do not create this object directly, use the Stellar class.
+ * @class
+ */
 export class AccountService {
-  private server: Server;
+  private server: Horizon.Server;
   private network: Networks;
 
+  /**
+   * Creates a new instance of the AccountService class.
+   * @constructor
+   * @param {Config} cfg - Configuration for the service.
+   */
   constructor(cfg: Config) {
     this.server = cfg.stellar.server;
     this.network = cfg.stellar.network;
@@ -22,8 +33,7 @@ export class AccountService {
   /**
    * Generate new account keypair (public and secret key). This key pair can be
    * used to create a Stellar account.
-   *
-   * @return public key and secret key
+   * @returns {SigningKeypair} Keypair capable of signing.
    */
   createKeypair(): SigningKeypair {
     return new SigningKeypair(Keypair.random());
@@ -32,8 +42,8 @@ export class AccountService {
   /**
    * Generate new account keypair (public and secret key) from random bytes. This key pair can be
    * used to create a Stellar account.
-   *
-   * @return public key and secret key
+   * @param {Buffer} randomBytes - Random bytes to create keypair from.
+   * @returns {SigningKeypair} Keypair capable of signing.
    */
   createKeypairFromRandom(randomBytes: Buffer): SigningKeypair {
     return new SigningKeypair(Keypair.fromRawEd25519Seed(randomBytes));
@@ -41,31 +51,31 @@ export class AccountService {
 
   /**
    * Get account information from the Stellar network.
-   *
-   * @param accountAddress Stellar address of the account
-   * @param serverInstance optional Horizon server instance when default doesn't work
-   * @return account information
+   * @param {object} params - The parameters for retrieving account information.
+   * @param {string} params.accountAddress - Stellar address of the account.
+   * @param {Horizon.HorizonApi.Server} [params.serverInstance=this.server] - Horizon server instance when default doesn't work.
+   * @returns {Promise<Horizon.ServerApi.AccountRecord>} Account information.
    */
   async getInfo({
     accountAddress,
     serverInstance = this.server,
   }: {
     accountAddress: string;
-    serverInstance?: Server;
-  }): Promise<ServerApi.AccountRecord> {
+    serverInstance?: Horizon.Server;
+  }): Promise<Horizon.ServerApi.AccountRecord> {
     return serverInstance.accounts().accountId(accountAddress).call();
   }
 
   /**
    * Get account operations for the specified Stellar address.
-   *
-   * @param accountAddress Stellar address of the account
-   * @param limit optional how many operations to fetch, maximum is 200, default is 10
-   * @param order optional data order, ascending or descending, defaults to descending
-   * @param cursor optional cursor to specify a starting point
-   * @param includeFailed optional flag to include failed operations, defaults to false
-   * @return a list of operations
-   * @throws [OperationsLimitExceededException] when maximum limit of 200 is exceeded
+   * @param {object} params - The parameters for retrieving account history.
+   * @param {string} params.accountAddress - Stellar address of the account
+   * @param {number} [params.limit=HORIZON_LIMIT_DEFAULT] - How many operations to fetch, maximum is 200, default is 10
+   * @param {HORIZON_ORDER} [params.order=HORIZON_ORDER.DESC] - Data order, ascending or descending, defaults to descending
+   * @param {string} [params.cursor] - Cursor to specify a starting point
+   * @param {boolean} [params.includeFailed=false] - Flag to include failed operations.
+   * @returns {Promise<Horizon.ServerApi.CollectionPage<Horizon.ServerApi.OperationRecord>>} A list of operations.
+   * @throws {OperationsLimitExceededError} when maximum limit of 200 is exceeded.
    */
   async getHistory({
     accountAddress,
@@ -79,7 +89,9 @@ export class AccountService {
     order?: HORIZON_ORDER;
     cursor?: string;
     includeFailed?: boolean;
-  }): Promise<ServerApi.CollectionPage<ServerApi.OperationRecord>> {
+  }): Promise<
+    Horizon.ServerApi.CollectionPage<Horizon.ServerApi.OperationRecord>
+  > {
     if (limit > HORIZON_LIMIT_MAX) {
       throw new OperationsLimitExceededError(HORIZON_LIMIT_MAX);
     }

package/src/walletSdk/Horizon/Stellar.ts

@@ -1,10 +1,11 @@
 import {
   Account as StellarAccount,
-  Server,
+  Horizon,
   Transaction,
   TransactionBuilder as StellarTransactionBuilder,
   FeeBumpTransaction,
 } from "stellar-sdk";
+import axios from "axios";
 
 import { Config } from "walletSdk";
 import { AccountService } from "./AccountService";
@@ -23,20 +24,44 @@ import {
 import { getResultCode } from "../Utils/getResultCode";
 import { SigningKeypair } from "./Account";
 
-// Do not create this object directly, use the Wallet class.
+/**
+ * Interaction with the Stellar Network.
+ * Do not create this object directly, use the Wallet class.
+ * @class
+ */
 export class Stellar {
   private cfg: Config;
-  server: Server;
+  server: Horizon.Server;
 
+  /**
+   * Creates a new instance of the Stellar class.
+   * @constructor
+   * @param {Config} cfg - Configuration object.
+   */
   constructor(cfg: Config) {
     this.cfg = cfg;
     this.server = cfg.stellar.server;
   }
 
+  /**
+   * Returns an AccountService instance for managing Stellar accounts.
+   * @returns {AccountService} An AccountService instance.
+   */
   account(): AccountService {
     return new AccountService(this.cfg);
   }
 
+  /**
+   * Construct a Stellar transaction.
+   * @param {TransactionParams} params - The Transaction params.
+   * @param {AccountKeypair} params.sourceAddress - The source account keypair.
+   * @param {Horizon.Server.Timebounds | number} [params.timebounds] - The timebounds for the transaction.
+   * If a number is given, then timebounds constructed from now to now + number in seconds.
+   * @param {number} [params.baseFee] - The base fee for the transaction. Defaults to the config base fee.
+   * @param {Memo} [params.memo] - The memo for the transaction.
+   * @returns {TransactionBuilder} A TransactionBuilder instance.
+   * @throws {AccountDoesNotExistError} If the source account does not exist.
+   */
   async transaction({
     sourceAddress,
     baseFee,
@@ -52,7 +77,7 @@ export class Stellar {
       throw new AccountDoesNotExistError(this.cfg.stellar.network);
     }
 
-    let formattedTimebounds: Server.Timebounds | undefined;
+    let formattedTimebounds: Horizon.Server.Timebounds | undefined;
     if (typeof timebounds === "number") {
       formattedTimebounds = {
         minTime: 0,
@@ -71,6 +96,14 @@ export class Stellar {
     );
   }
 
+  /**
+   * Creates a FeeBumpTransaction instance for increasing the fee of an existing transaction.
+   * @param {FeeBumpTransactionParams} params - The Fee Bump Transaction params.
+   * @param {AccountKeypair} params.feeAddress - The account that will pay for the transaction's fee.
+   * @param {Transaction} params.transaction - The transaction to be fee bumped.
+   * @param {number} [params.baseFee] - The base fee (stroops) for the fee bump transaction. Defaults to the config base fee.
+   * @returns {FeeBumpTransaction} A FeeBumpTransaction instance.
+   */
   makeFeeBump({
     feeAddress,
     transaction,
@@ -84,6 +117,13 @@ export class Stellar {
     );
   }
 
+  /**
+   * Submits a signed transaction to the server. If the submission fails with status
+   * 504 indicating a timeout error, it will automatically retry.
+   * @param {Transaction|FeeBumpTransaction} signedTransaction - The signed transaction to submit.
+   * @returns {boolean} `true` if the transaction was successfully submitted.
+   * @throws {TransactionSubmitFailedError} If the transaction submission fails.
+   */
   async submitTransaction(
     signedTransaction: Transaction | FeeBumpTransaction,
   ): Promise<boolean> {
@@ -104,6 +144,25 @@ export class Stellar {
     }
   }
 
+  /**
+   * Submits a signed transaction. If the submission fails with error code: tx_too_late,
+   * then resubmit with an increased base fee.
+   * @see {@link https://developers.stellar.org/docs/encyclopedia/error-handling#retrying-until-success-strategy}
+   * for more info on this strategy.
+   * @param {SubmitWithFeeIncreaseParams} params - The SubmitWithFeeIncrease params.
+   * @param {AccountKeypair} params.sourceAddress - The source account keypair.
+   * @param {number} params.timeout - The number of seconds from now the transaction is allowed to be submitted.
+   * @param {number} params.baseFeeIncrease - The amount to increase base fee (in stroops) if submission fails.
+   * @param {(builder: TransactionBuilder) => TransactionBuilder} params.buildingFunction - Function for building the
+   * operations of the transactions.
+   * @param {(builder: TransactionBuilder) => TransactionBuilder} [params.signerFunction] - Function for signing the transaction.
+   * If not given, will use the soure keypair to sign.
+   * @param {number} [params.baseFee] - The base fee (stroops) of the transaction.
+   * @param {Memo} [params.memo] - The memo of the transaction.
+   * @param {number} [params.maxFee] - The max fee allowed (stroops) of the transaction, afterward will stop submitting and throw error.
+   * @returns {Transaction} The submitted transaction.
+   * @throws {TransactionSubmitWithFeeIncreaseFailedError} If the transaction submission with fee increase fails.
+   */
   async submitWithFeeIncrease({
     sourceAddress,
     timeout,
@@ -133,7 +192,7 @@ export class Stellar {
     }
 
     try {
-      const success = await this.submitTransaction(transaction);
+      await this.submitTransaction(transaction);
       return transaction;
     } catch (e) {
       const resultCode = getResultCode(e);
@@ -158,7 +217,32 @@ export class Stellar {
     }
   }
 
+  /**
+   * Decodes a Stellar transaction from xdr.
+   * @param {string} xdr - The XDR representation of the transaction.
+   * @returns {Transaction|FeeBumpTransaction} The decoded transaction.
+   */
   decodeTransaction(xdr: string): Transaction | FeeBumpTransaction {
     return StellarTransactionBuilder.fromXDR(xdr, this.cfg.stellar.network);
   }
+
+  /**
+   * Returns the recommended fee (stroops) to use in a transaction based on the current
+   * stellar network fee stats.
+   * @returns {string} The recommended fee amount in stroops.
+   */
+  async getRecommendedFee(): Promise<string> {
+    const stats = await this.server.feeStats();
+    return stats.max_fee.mode;
+  }
+
+  /**
+   * Funds an account on the stellar test network. If it is already funded then call will error.
+   * Please note: only funds on the testnet network.
+   * @see {@link https://developers.stellar.org/docs/fundamentals-and-concepts/testnet-and-pubnet#friendbot}
+   * @param {string} address - The stellar address.
+   */
+  async fundTestnetAccount(address: string) {
+    await axios.get(`https://friendbot.stellar.org/?addr=${address}`);
+  }
 }

package/src/walletSdk/Horizon/Transaction/CommonTransactionBuilder.ts

@@ -11,6 +11,12 @@ export abstract class CommonTransactionBuilder<T> {
     this.operations = operations;
   }
 
+  /**
+   * Add a trustline for an asset so can receive or send it.
+   * @param {IssuedAssetId} asset - The asset for which support is added.
+   * @param {string} [trustLimit] - The trust limit for the asset.
+   * @returns {T} The builder class instance called with.
+   */
   addAssetSupport(asset: IssuedAssetId, trustLimit?: string): T {
     this.operations.push(
       StellarSdk.Operation.changeTrust({
@@ -19,13 +25,25 @@ export abstract class CommonTransactionBuilder<T> {
         source: this.sourceAddress,
       }),
     );
-    return this as any as T;
+    return this as unknown as T;
   }
 
+  /**
+   * Remove a trustline for an asset.
+   * @param {IssuedAssetId} asset - The asset for which support is added.
+   * @returns {T} The builder class instance called with.
+   */
   removeAssetSupport(asset: IssuedAssetId): T {
     return this.addAssetSupport(asset, "0");
   }
 
+  /**
+   * Add a signer to the account.
+   * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig}
+   * @param {AccountKeypair} signerAddress - The new account being added
+   * @param {number} signerWeight - The weight given to the new signer.
+   * @returns {T} The builder class instance called with.
+   */
   addAccountSigner(signerAddress: AccountKeypair, signerWeight: number): T {
     this.operations.push(
       StellarSdk.Operation.setOptions({
@@ -36,13 +54,25 @@ export abstract class CommonTransactionBuilder<T> {
         },
       }),
     );
-    return this as any as T;
+    return this as unknown as T;
   }
 
+  /**
+   * Removes a signer from an account.
+   * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig}
+   * @param {AccountKeypair} signerAddress - The new account being added
+   * @returns {T} The builder class instance called with.
+   */
   removeAccountSigner(signerAddress: AccountKeypair): T {
     return this.addAccountSigner(signerAddress, 0);
   }
 
+  /**
+   * Locking an account by setting the master key weight to 0.
+   * Be careful, if no other signers then the account will be locked and unable to
+   * sign new transactions permanently.
+   * @returns {T} The builder class instance called with.
+   */
   lockAccountMasterKey(): T {
     this.operations.push(
       StellarSdk.Operation.setOptions({
@@ -50,9 +80,18 @@ export abstract class CommonTransactionBuilder<T> {
         masterWeight: 0,
       }),
     );
-    return this as any as T;
+    return this as unknown as T;
   }
 
+  /**
+   * Set thesholds for an account.
+   * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig#thresholds}
+   * @param {object} options - The threshold options.
+   * @param {number} [options.low] - The low theshold level.
+   * @param {number} [options.medium] - The medium theshold level.
+   * @param {number} [options.high] - The high theshold level.
+   * @returns {T} The builder class instance called with.
+   */
   setThreshold({
     low,
     medium,
@@ -70,6 +109,6 @@ export abstract class CommonTransactionBuilder<T> {
         highThreshold: high,
       }),
     );
-    return this as any as T;
+    return this as unknown as T;
   }
 }