feat: 🎸 add method to validate if an address is a valid module

isValidModule use isModule contract method to verify if an address and
module type are valid or not, preventing runtime errors

Author: shuffledex

src/contract_wrappers/modules/module_factory_wrapper.ts

@@ -170,7 +170,7 @@ export default class ModuleFactoryWrapper extends ContractWrapper {
    */
   public getTypes = async (): Promise<ModuleType[]> => {
     return (await (await this.contract).getTypes.callAsync()).map(type => {
-      return parseModuleTypeValue(type);
+      return parseModuleTypeValue(new BigNumber(type));
     });
   };
 

src/contract_wrappers/modules/module_wrapper.ts

@@ -5,11 +5,12 @@ import {
   ERC20DetailedContract,
   Web3Wrapper,
   TxData,
+  BigNumber,
 } from '@polymathnetwork/abi-wrappers';
 import ContractWrapper from '../contract_wrapper';
 import ContractFactory from '../../factories/contractFactory';
 import { TxParams, GenericModuleContract, GetLogs, Subscribe } from '../../types';
-import { stringToBytes32 } from '../../utils/convert';
+import { stringToBytes32, parseModuleTypeValue } from '../../utils/convert';
 import functionsUtils from '../../utils/functions_utils';
 import assert from '../../utils/assert';
 
@@ -97,6 +98,31 @@ export default class ModuleWrapper extends ContractWrapper {
     );
   };
 
+  public isValidModule = async () => {
+    const moduleFactoryContract = await this.moduleFactoryContract();
+    const getTypes = await moduleFactoryContract.getTypes.callAsync();
+    const types = getTypes.filter(type => {
+      // type '6' is valid but it is not mapped, so we must filter this kind of scenarios
+      try {
+        parseModuleTypeValue(new BigNumber(type));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+    // if empty, module type is invalid
+    if (!types.length) {
+      return false;
+      // if types has more than one element, prevent further errors
+    }
+    if (types.length > 1) {
+      return false;
+    }
+    const address = await this.address();
+    const result = await (await this.securityTokenContract()).isModule.callAsync(address, types[0]);
+    return result;
+  };
+
   protected isCallerTheSecurityTokenOwner = async (txData: Partial<TxData> | undefined): Promise<boolean> => {
     const from = await this.getCallerAddress(txData);
     return functionsUtils.checksumAddressComparision(

src/factories/moduleWrapperFactory.ts

@@ -105,88 +105,109 @@ export default class ModuleWrapperFactory {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   public getModuleInstance: GetModuleInstance = async (params: GetModuleParams): Promise<any> => {
     assert.isETHAddressHex('address', params.address);
+    let moduleWrapper;
     switch (params.name) {
       // Permission
       case ModuleName.GeneralPermissionManager:
-        return new GeneralPermissionManagerWrapper(
+        moduleWrapper = new GeneralPermissionManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getGeneralPermissionManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       // TMs
       case ModuleName.CountTransferManager:
-        return new CountTransferManagerWrapper(
+        moduleWrapper = new CountTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getCountTransferManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.GeneralTransferManager:
-        return new GeneralTransferManagerWrapper(
+        moduleWrapper = new GeneralTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getGeneralTransferManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.ManualApprovalTransferManager:
-        return new ManualApprovalTransferManagerWrapper(
+        moduleWrapper = new ManualApprovalTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getManualApprovalTransferManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.PercentageTransferManager:
-        return new PercentageTransferManagerWrapper(
+        moduleWrapper = new PercentageTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getPercentageTransferManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.LockUpTransferManager:
-        return new LockUpTransferManagerWrapper(
+        moduleWrapper = new LockUpTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getLockUpTransferManagerContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.VolumeRestrictionTM:
-        return new VolumeRestrictionTransferManagerWrapper(
+        moduleWrapper = new VolumeRestrictionTransferManagerWrapper(
           this.web3Wrapper,
           this.contractFactory.getVolumeRestrictionTMContract(params.address),
           this.contractFactory,
         );
+        break;
       // STOs
       case ModuleName.CappedSTO:
-        return new CappedSTOWrapper(
+        moduleWrapper = new CappedSTOWrapper(
           this.web3Wrapper,
           this.contractFactory.getCappedSTOContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.UsdTieredSTO:
-        return new USDTieredSTOWrapper(
+        moduleWrapper = new USDTieredSTOWrapper(
           this.web3Wrapper,
           this.contractFactory.getUSDTieredSTOContract(params.address),
           this.contractFactory,
         );
+        break;
       // Checkpoint
       case ModuleName.ERC20DividendCheckpoint:
-        return new ERC20DividendCheckpointWrapper(
+        moduleWrapper = new ERC20DividendCheckpointWrapper(
           this.web3Wrapper,
           this.contractFactory.getERC20DividendCheckpointContract(params.address),
           this.contractFactory,
         );
+        break;
       case ModuleName.EtherDividendCheckpoint:
-        return new EtherDividendCheckpointWrapper(
+        moduleWrapper = new EtherDividendCheckpointWrapper(
           this.web3Wrapper,
           this.contractFactory.getEtherDividendCheckpointContract(params.address),
           this.contractFactory,
         );
+        break;
       // Wallet
       case ModuleName.VestingEscrowWallet:
-        return new VestingEscrowWalletWrapper(
+        moduleWrapper = new VestingEscrowWalletWrapper(
           this.web3Wrapper,
           this.contractFactory.getVestingEscrowWalletContract(params.address),
           this.contractFactory,
         );
+        break;
       // Burn
       default:
         // TODO: Typed error here
         throw new Error();
     }
+
+    // validate module
+    if (await moduleWrapper.isValidModule()) {
+      return moduleWrapper;
+    }
+
+    // TODO: Typed error here
+    throw new Error('Invalid module');
   };
 }