feat: 🎸 manualApprovalTM comments. remove lint warning

Author: Victor Wiebe

src/contract_wrappers/modules/checkpoint/__tests__/dividend_checkpoint_wrapper.test.ts

@@ -12,7 +12,6 @@ import ContractFactory from '../../../../factories/contractFactory';
 import {
   bytes32ToString,
   dateToBigNumber,
-  numberToBigNumber,
   stringToBytes32,
   valueArrayToWeiArray,
   weiToValue,

src/contract_wrappers/modules/transfer_manager/__tests__/manual_approval_transfer_manager_wrapper.test.ts

@@ -950,7 +950,7 @@ describe('ManualApprovalTransferManagerWrapper', () => {
       // Real call
       const result = await target.getTotalApprovalsLength();
       // Result expectation
-      expect(result).toBe(expectedResult);
+      expect(result).toBe(expectedResult.toNumber());
       // Verifications
       verify(mockedContract.getTotalApprovalsLength).once();
       verify(mockedMethod.callAsync()).once();

src/contract_wrappers/modules/transfer_manager/manual_approval_transfer_manager_wrapper.ts

@@ -105,17 +105,33 @@ interface GetManualApprovalTransferManagerLogsAsyncParams extends GetLogs {
   (params: GetUnpauseLogsAsyncParams): Promise<LogWithDecodedArgs<ManualApprovalTransferManagerUnpauseEventArgs>[]>;
 }
 
+/**
+ * @param index
+ */
 interface ApprovalsParams {
   index: number;
 }
 
+/**
+ * @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 from is the address from which transfers are approved
+ * @param to is the address to which transfers are approved
+ * @param allowance is the approved amount of tokens
+ * @param expiryTime is the time until which the transfer is allowed
+ * @param description Description about the manual approval
+ */
 interface AddManualApprovalParams extends TxParams {
   from: string;
   to: string;
@@ -124,6 +140,13 @@ interface AddManualApprovalParams extends TxParams {
   description: string;
 }
 
+/**
+ * @param from is the address array from which transfers are approved
+ * @param to is the address array to which transfers are approved
+ * @param allowances is the array of approved amounts
+ * @param expiryTimes is the array of the times until which eath transfer is allowed
+ * @param descriptions is the description array for these manual approvals
+ */
 interface AddManualApprovalMultiParams extends TxParams {
   from: string[];
   to: string[];
@@ -132,6 +155,15 @@ interface AddManualApprovalMultiParams extends TxParams {
   descriptions: string[];
 }
 
+/**
+ * @param from is the address from which transfers are approved
+ * @param to is the address to which transfers are approved
+ * @param expiryTime is the time until which the transfer is allowed
+ * @param changeInAllowance is the change in allowance
+ * @param description Description about the manual approval
+ * @param increase tells whether the allowances will be increased (true) or decreased (false).
+ * or any value when there is no change in allowances
+ */
 interface ModifyManualApprovalParams extends TxParams {
   from: string;
   to: string;
@@ -141,6 +173,15 @@ interface ModifyManualApprovalParams extends TxParams {
   increase: boolean;
 }
 
+/**
+ * @param from is the address array from which transfers are approved
+ * @param to is the address array to which transfers are approved
+ * @param expiryTimes is the array of the times until which each transfer is allowed
+ * @param changeInAllowance is the array of change in allowances
+ * @param descriptions is the description array for these manual approvals
+ * @param increase Array of bools that tells whether the allowances will be increased (true) or decreased (false).
+ * or any value when there is no change in allowances
+ */
 interface ModifyManualApprovalMultiParams extends TxParams {
   from: string[];
   to: string[];
@@ -150,20 +191,36 @@ interface ModifyManualApprovalMultiParams extends TxParams {
   increase: boolean[];
 }
 
+/**
+ * @param from is the address from which transfers are approved
+ * @param to is the address to which transfers are approved
+ */
 interface RevokeManualApprovalParams extends TxParams {
   from: string;
   to: string;
 }
 
+/**
+ * @param from is the address array from which transfers are approved
+ * @param to is the address array to which transfers are approved
+ */
 interface RevokeManualApprovalMultiParams extends TxParams {
   from: string[];
   to: string[];
 }
 
+/**
+ * @param user Address of the holder corresponds to whom list of manual approvals
+ * need to return
+ */
 interface GetActiveApprovalsToUserParams {
   user: string;
 }
 
+/**
+ * @param from Address of the sender
+ * @param to Address of the receiver
+ */
 interface GetApprovalDetailsParams {
   from: string;
   to: string;
@@ -204,22 +261,36 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     this.contract = contract;
   }
 
+  /**
+   *  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);
   };
 
+  /**
+   *  check if the module is paused
+   */
   public paused = async () => {
     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);
   };
 
+  /**
+   *  An array to track all approvals. It is an unbounded array but it's not a problem as
+   * it is never looped through in an on chain call. It is defined as an Array instead of mapping
+   * just to make it easier for users to fetch list of all approvals through constant functions.
+   */
   public approvals = async (params: ApprovalsParams) => {
     const result = await (await this.contract).approvals.callAsync(numberToBigNumber(params.index));
     const decimals = await (await this.securityTokenContract()).decimals.callAsync();
@@ -233,10 +304,20 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     return typedResult;
   };
 
-  public getInitFunction = async () => {
+  /**
+   * This function returns the signature of configure function
+   */
+  public getInitFunction = async (): Promise<string> => {
     return (await this.contract).getInitFunction.callAsync();
   };
 
+  /**
+   * 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
+   */
   public verifyTransfer = async (params: VerifyTransferParams) => {
     assert.isETHAddressHex('from', params.from);
     assert.isETHAddressHex('to', params.to);
@@ -254,6 +335,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     };
   };
 
+  /**
+   * Adds a pair of addresses to manual approvals
+   */
   public addManualApproval = async (params: AddManualApprovalParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.isETHAddressHex('from', params.from);
@@ -273,6 +357,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
+  /**
+   * Adds multiple manual approvals in batch
+   */
   public addManualApprovalMulti = async (params: AddManualApprovalMultiParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     params.from.forEach(address => assert.isETHAddressHex('from', address));
@@ -305,6 +392,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
+  /**
+   * Modify the existing manual approvals
+   */
   public modifyManualApproval = async (params: ModifyManualApprovalParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.isETHAddressHex('from', params.from);
@@ -324,6 +414,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
+  /**
+   * Adds multiple manual approvals in batch
+   */
   public modifyManualApprovalMulti = async (params: ModifyManualApprovalMultiParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     params.from.forEach(address => assert.isETHAddressHex('from', address));
@@ -354,6 +447,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
+  /**
+   * Removes pairs of addresses from manual approvals
+   */
   public revokeManualApproval = async (params: RevokeManualApprovalParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     assert.isETHAddressHex('from', params.from);
@@ -367,6 +463,9 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
+  /**
+   * Removes multiple pairs of addresses from manual approvals
+   */
   public revokeManualApprovalMulti = async (params: RevokeManualApprovalMultiParams) => {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
     params.from.forEach(address => assert.isETHAddressHex('from', address));
@@ -385,7 +484,15 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     );
   };
 
-  public getActiveApprovalsToUser = async (params: GetActiveApprovalsToUserParams) => {
+  /**
+   * Returns the all active approvals corresponds to an address
+   * @return addresses from
+   * @return addresses to
+   * @return allowances provided to the approvals
+   * @return expiry times provided to the approvals
+   * @return descriptions provided to the approvals
+   */
+  public getActiveApprovalsToUser = async (params: GetActiveApprovalsToUserParams): Promise<Approval[]> => {
     assert.isETHAddressHex('user', params.user);
     const result = await (await this.contract).getActiveApprovalsToUser.callAsync(params.user);
     const typedResult: Approval[] = [];
@@ -403,7 +510,13 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     return typedResult;
   };
 
-  public getApprovalDetails = async (params: GetApprovalDetailsParams) => {
+  /**
+   * Get the details of the approval corresponds to from & to addresses
+   * @return expiryTime of the approval
+   * @return allowance provided to the approval
+   * @return Description provided to the approval
+   */
+  public getApprovalDetails = async (params: GetApprovalDetailsParams): Promise<Approval> => {
     assert.isETHAddressHex('from', params.from);
     assert.isETHAddressHex('to', params.to);
     const result = await (await this.contract).getApprovalDetails.callAsync(params.from, params.to);
@@ -418,11 +531,22 @@ export default class ManualApprovalTransferManagerWrapper extends ModuleWrapper
     return typedResult;
   };
 
-  public getTotalApprovalsLength = async () => {
-    return (await this.contract).getTotalApprovalsLength.callAsync();
+  /**
+   * Returns the current number of active approvals
+   */
+  public getTotalApprovalsLength = async (): Promise<number> => {
+    return (await (await this.contract).getTotalApprovalsLength.callAsync()).toNumber();
   };
 
-  public getAllApprovals = async () => {
+  /**
+   * Get the details of all approvals
+   * @return addresses from
+   * @return addresses to
+   * @return allowances provided to the approvals
+   * @return expiry times provided to the approvals
+   * @return descriptions provided to the approvals
+   */
+  public getAllApprovals = async (): Promise<Approval[]> => {
     const result = await (await this.contract).getAllApprovals.callAsync();
     const decimals = await (await this.securityTokenContract()).decimals.callAsync();
     const typedResult: Approval[] = [];