feat: 🎸 fix comments inside of percentageTM

Author: Victor Wiebe

src/contract_wrappers/modules/transfer_manager/blacklist_transfer_manager_wrapper.ts

@@ -683,7 +683,8 @@ export default class BlacklistTransferManagerWrapper extends ModuleWrapper {
    * Restrict the blacklist address to transfer tokens
    * if the current time is between the timeframe define for the
    * blacklist type associated with the from address
-   * @return Parse transfer result
+   *  @return boolean transfer result
+   *  @return address
    */
   public verifyTransfer = async (params: VerifyTransferParams): Promise<VerifyTransfer> => {
     assert.isETHAddressHex('from', params.from);

src/contract_wrappers/modules/transfer_manager/count_transfer_manager_wrapper.ts

@@ -139,13 +139,9 @@ export default class CountTransferManagerWrapper extends ModuleWrapper {
   };
 
   /**
-   *Used to verify the transfer transaction and prevent a transfer if it passes the allowed amount of token holders
-   * @dev module.verifyTransfer is called by SecToken.canTransfer and does not receive the updated holderCount therefore
-   *      verifyTransfer has to manually account for pot. tokenholder changes (by mimicking TokenLib.adjustInvestorCount).
-   *      module.executeTransfer is called by SecToken.transfer|issue|others and receives an updated holderCount
-   *      as sectoken calls TokenLib.adjustInvestorCount before executeTransfer.
-   *      @return boolean transfer result
-   *      @return address
+   *  Used to verify the transfer transaction and prevent a transfer if it passes the allowed amount of token holders
+   *  @return boolean transfer result
+   *  @return address
    */
   public verifyTransfer = async (params: VerifyTransferParams) => {
     assert.isETHAddressHex('from', params.from);

src/contract_wrappers/modules/transfer_manager/lock_up_transfer_manager_wrapper.ts

@@ -487,7 +487,9 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
   };
 
   /**
-   * Used to verify the transfer transaction and prevent locked up tokens from being transferred
+   *  Used to verify the transfer transaction and prevent locked up tokens from being transferred
+   *  @return boolean transfer result
+   *  @return address
    */
   public verifyTransfer = async (params: VerifyTransferParams): Promise<VerifyTransfer> => {
     assert.isETHAddressHex('from', params.from);

src/contract_wrappers/modules/transfer_manager/manual_approval_transfer_manager_wrapper.ts

@@ -313,10 +313,8 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
 
   /**
    * Used to verify the transfer transaction (View)
-   * Restrict the blacklist address to transfer tokens
-   * if the current time is between the time frame define for the
-   * blacklist type associated with the from address
-   * @return Parse transfer result
+   *  @return boolean transfer result
+   *  @return address
    */
   public verifyTransfer = async (params: VerifyTransferParams) => {
     assert.isETHAddressHex('from', params.from);

src/contract_wrappers/modules/transfer_manager/percentage_transfer_manager_wrapper.ts

@@ -94,31 +94,54 @@ interface GetPercentageTransferManagerLogsAsyncParams extends GetLogs {
   (params: GetUnpauseLogsAsyncParams): Promise<LogWithDecodedArgs<PercentageTransferManagerUnpauseEventArgs>[]>;
 }
 
+/**
+ * @param investorAddress Address of the investor
+ */
 interface InvestorAddressParams {
   investorAddress: string;
 }
 
+/**
+ * @param from Address of the sender
+ * @param to Address of the receiver
+ * @param amount
+ * @param data
+ */
 interface VerifyTransferParams {
   from: string;
   to: string;
   amount: BigNumber;
   data: string;
 }
 
+/**
+ * @param maxHolderPercentage is the new maximum percentage
+ */
 interface ChangeHolderPercentageParams extends TxParams {
   maxHolderPercentage: BigNumber;
 }
 
+/**
+ * @param investor is the address to whitelist
+ * @param valid whether or not the address it to be added or removed from the whitelist
+ */
 interface ModifyWhitelistParams extends TxParams {
   investor: string;
   valid: boolean;
 }
 
+/**
+ * @param investors Array of the addresses to whitelist
+ * @param valids Array of boolean value to decide whether or not the address it to be added or removed from the whitelist
+ */
 interface ModifyWhitelistMultiParams extends TxParams {
   investors: string[];
   valids: boolean[];
 }
 
+/**
+ * @param allowPrimaryIssuance whether to allow all primary issuance transfers
+ */
 interface SetAllowPrimaryIssuanceParams extends TxParams {
   allowPrimaryIssuance: boolean;
 }
@@ -143,36 +166,62 @@ export default class PercentageTransferManagerWrapper extends ModuleWrapper {
     this.contract = contract;
   }
 
-  public allowPrimaryIssuance = async () => {
+  /**
+   * Ignore transactions which are part of the primary issuance
+   * @return boolean allowed
+   */
+  public allowPrimaryIssuance = async (): Promise<boolean> => {
     return (await this.contract).allowPrimaryIssuance.callAsync();
   };
 
-  public maxHolderPercentage = async () => {
+  /**
+   * Maximum percentage that any holder can have, multiplied by 10**16
+   * @return percentage value
+   */
+  public maxHolderPercentage = async (): Promise<BigNumber> => {
     const result = await (await this.contract).maxHolderPercentage.callAsync();
     return weiToValue(result, PERCENTAGE_DECIMALS);
   };
 
+  /**
+   *  unpause the module
+   */
   public unpause = async (params: TxParams) => {
     assert.assert(await this.paused(), 'Controller not currently paused');
     assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'Sender is not owner');
     return (await this.contract).unpause.sendTransactionAsync(params.txData, params.safetyFactor);
   };
 
-  public paused = async () => {
+  /**
+   *  check if module is paused
+   */
+  public paused = async (): Promise<boolean> => {
     return (await this.contract).paused.callAsync();
   };
 
+  /**
+   *  pause the module
+   */
   public pause = async (params: TxParams) => {
     assert.assert(!(await this.paused()), 'Controller currently paused');
     assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'Sender is not owner');
     return (await this.contract).pause.sendTransactionAsync(params.txData, params.safetyFactor);
   };
 
-  public whitelist = async (params: InvestorAddressParams) => {
+  /**
+   * Addresses on this list are always able to send / receive tokens
+   * @return boolean on whitelist
+   */
+  public whitelist = async (params: InvestorAddressParams): Promise<boolean> => {
     assert.isETHAddressHex('investorAddress', params.investorAddress);
     return (await this.contract).whitelist.callAsync(params.investorAddress);
   };
 
+  /**
+   * Used to verify the transfer transaction (View)
+   *  @return boolean transfer result
+   *  @return address
+   */
   public verifyTransfer = async (params: VerifyTransferParams) => {
     assert.isETHAddressHex('from', params.from);
     assert.isETHAddressHex('to', params.to);
@@ -190,6 +239,9 @@ export default class PercentageTransferManagerWrapper extends ModuleWrapper {
     };
   };
 
+  /**
+   * sets the maximum percentage that an individual token holder can hold
+   */
   public changeHolderPercentage = async (params: ChangeHolderPercentageParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.isPercentage('maxHolderPercentage', params.maxHolderPercentage);
@@ -200,6 +252,9 @@ export default class PercentageTransferManagerWrapper extends ModuleWrapper {
     );
   };
 
+  /**
+   * Adds or removes single addresses from the whitelist.
+   */
   public modifyWhitelist = async (params: ModifyWhitelistParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.isETHAddressHex('investor', params.investor);
@@ -211,6 +266,9 @@ export default class PercentageTransferManagerWrapper extends ModuleWrapper {
     );
   };
 
+  /**
+   * Adds or removes addresses from the whitelist.
+   */
   public modifyWhitelistMulti = async (params: ModifyWhitelistMultiParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.assert(
@@ -226,6 +284,9 @@ export default class PercentageTransferManagerWrapper extends ModuleWrapper {
     );
   };
 
+  /**
+   * Sets whether or not to consider primary issuance transfers
+   */
   public setAllowPrimaryIssuance = async (params: SetAllowPrimaryIssuanceParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.assert(