feat: add whitelist specific code

Author: remon-nashid

src/LowLevel/GeneralPermissionManager.ts

@@ -4,9 +4,14 @@ import { Contract } from './Contract';
 import { Context } from './LowLevel';
 import { isAddress, getOptions } from './utils';
 
-import { GenericContract } from './types';
-import { PolymathError } from '~/PolymathError';
-import { ErrorCodes } from '~/types';
+import {
+  GenericContract,
+  AddDelegateArgs,
+  ChangePermissionArgs,
+  GetAllDelegatesWithPermArgs,
+} from './types';
+import { PolymathError } from '../PolymathError';
+import { ErrorCodes } from '../types';
 
 interface GeneralPermissionManagerContract extends GenericContract {
   methods: {
@@ -17,6 +22,8 @@ interface GeneralPermissionManagerContract extends GenericContract {
       perm: string,
       valid: boolean
     ) => TransactionObject<void>;
+    getAllDelegates: () => TransactionObject<string[]>;
+    getAllDelegatesWithPerm: (module: string, perm: string) => TransactionObject<string[]>;
   };
 }
 
@@ -29,7 +36,15 @@ export class GeneralPermissionManager extends Contract<GeneralPermissionManagerC
     });
   }
 
-  public addDelegate = async (delegate: string, details: string) => {
+  public getAllDelegates = async () => {
+    return await this.contract.methods.getAllDelegates().call();
+  };
+
+  public getAllDelegatesWithPerm = async ({ module, perm }: GetAllDelegatesWithPermArgs) => {
+    return await this.contract.methods.getAllDelegatesWithPerm(module, perm).call();
+  };
+
+  public addDelegate = async ({ delegate, details }: AddDelegateArgs) => {
     if (!isAddress(delegate))
       throw new PolymathError({
         code: ErrorCodes.InvalidAddress,
@@ -41,19 +56,14 @@ export class GeneralPermissionManager extends Contract<GeneralPermissionManagerC
     return () => method.send(options);
   };
 
-  public changePermission = async (
-    delegate: string,
-    module: string,
-    perm: string,
-    valid: boolean
-  ) => {
+  public changePermission = async ({ delegate, module, perm, enabled }: ChangePermissionArgs) => {
     if (!isAddress(delegate))
       throw new PolymathError({
         code: ErrorCodes.InvalidAddress,
         message: `Delegate address is invalid: $delegate = ${delegate}`,
       });
 
-    const method = this.contract.methods.changePermission(delegate, module, perm, valid);
+    const method = this.contract.methods.changePermission(delegate, module, perm, enabled);
     const options = await getOptions(method, { from: this.context.account });
     return () => method.send(options);
   };

src/LowLevel/GeneralTransferManager.ts

@@ -0,0 +1,19 @@
+import { GeneralTransferManagerAbi } from './abis/GeneralTransferManagerAbi';
+import { Contract } from './Contract';
+import { Context } from './LowLevel';
+
+import { GenericContract } from './types';
+
+interface GeneralTransferManagerContract extends GenericContract {
+  methods: {};
+}
+
+export class GeneralTransferManager extends Contract<GeneralTransferManagerContract> {
+  constructor({ address, context }: { address: string; context: Context }) {
+    super({
+      address,
+      abi: GeneralTransferManagerAbi.abi,
+      context,
+    });
+  }
+}

src/LowLevel/SecurityToken.ts

@@ -22,6 +22,8 @@ import { DividendCheckpointAbi } from './abis/DividendCheckpointAbi';
 import { Contract } from './Contract';
 import { CappedSto } from './CappedSto';
 import { UsdTieredSto } from './UsdTieredSto';
+import { GeneralPermissionManager } from './GeneralPermissionManager';
+import { GeneralTransferManager } from './GeneralTransferManager';
 
 interface ModuleData {
   /**
@@ -133,6 +135,8 @@ export class SecurityToken extends Contract<SecurityTokenContract> {
     return () => method.send(options);
   };
 
+  // @TODO remon-nashid: add a generic getAttachedModule(moduleName) method. It should still return properly typed module objects.
+
   public getErc20DividendModule = async () => {
     const address = await this.getFirstUnarchivedModuleAddress({
       name: 'ERC20DividendCheckpoint',
@@ -157,6 +161,30 @@ export class SecurityToken extends Contract<SecurityTokenContract> {
     return new EtherDividendCheckpoint({ address, context: this.context });
   }
 
+  public getGeneralPermissionManagerModule = async () => {
+    const address = await this.getFirstUnarchivedModuleAddress({
+      name: 'GeneralPermissionManager',
+    });
+
+    if (!address) {
+      return null;
+    }
+
+    return new GeneralPermissionManager({ address, context: this.context });
+  };
+
+  public getGeneralTransferManagerModule = async () => {
+    const address = await this.getFirstUnarchivedModuleAddress({
+      name: 'GeneralTransferManager',
+    });
+
+    if (!address) {
+      return null;
+    }
+
+    return new GeneralTransferManager({ address, context: this.context });
+  };
+
   public async getCappedStoModules() {
     const addresses = await this.getUnarchivedModuleAddresses({
       name: 'CappedSTO',