fix: 🐛 manual merge from develop and improve comments

Author: shuffledex

.eslintrc.js

@@ -21,6 +21,7 @@ module.exports = {
     // Place to specify ESLint rules. Can be used to overwrite rules specified from the extended configs
     // e.g. "@typescript-eslint/explicit-function-return-type": "off",
     '@typescript-eslint/explicit-function-return-type': 'off',
+    "import/prefer-default-export": 'off',
     'jest/expect-expect': 'error',
     'jest/no-empty-title': 'warn',
     'jest/no-truthy-falsy': 'warn',

examples/blacklistTransferManager.ts

@@ -0,0 +1,202 @@
+import { RedundantSubprovider, RPCSubprovider, Web3ProviderEngine } from '@0x/subproviders';
+import ModuleFactoryWrapper from '../src/contract_wrappers/modules/module_factory_wrapper';
+import { ApiConstructorParams, PolymathAPI } from '../src/PolymathAPI';
+import { ModuleName, ModuleType } from '../src';
+import { BigNumber, ModuleRegistryEvents, BlacklistTransferManagerEvents } from '@polymathnetwork/abi-wrappers';
+
+// This file acts as a valid sandbox for using a blacklist restriction transfer manager module on an unlocked node (like ganache)
+window.addEventListener('load', async () => {
+  // Setup the redundant provider
+  const providerEngine = new Web3ProviderEngine();
+  providerEngine.addProvider(new RedundantSubprovider([new RPCSubprovider('http://127.0.0.1:8545')]));
+  providerEngine.start();
+  const params: ApiConstructorParams = {
+    provider: providerEngine,
+    polymathRegistryAddress: '<Deployed Polymath Registry address>',
+  };
+
+  // Instantiate the API
+  const polymathAPI = new PolymathAPI(params);
+
+  // Get some poly tokens in your account and the security token
+  const myAddress = await polymathAPI.getAccount();
+  await polymathAPI.getPolyTokens({ amount: new BigNumber(1000000), address: myAddress });
+
+  // Prompt to setup your ticker and token name
+  const ticker = prompt('Ticker', '');
+  const tokenName = prompt('Token Name', '');
+
+  // Double check available
+  await polymathAPI.securityTokenRegistry.tickerAvailable({
+    ticker: ticker!,
+  });
+  // Get the ticker fee and approve the security token registry to spend
+  const tickerFee = await polymathAPI.securityTokenRegistry.getTickerRegistrationFee();
+  await polymathAPI.polyToken.approve({
+    spender: await polymathAPI.securityTokenRegistry.address(),
+    value: tickerFee,
+  });
+  // Register a ticker
+  await polymathAPI.securityTokenRegistry.registerTicker({
+    ticker: ticker!,
+    tokenName: tokenName!,
+  });
+  // Get the st launch fee and approve the security token registry to spend
+  const securityTokenLaunchFee = await polymathAPI.securityTokenRegistry.getSecurityTokenLaunchFee();
+  await polymathAPI.polyToken.approve({
+    spender: await polymathAPI.securityTokenRegistry.address(),
+    value: securityTokenLaunchFee,
+  });
+
+  await polymathAPI.securityTokenRegistry.generateNewSecurityToken({
+    name: tokenName!,
+    ticker: ticker!,
+    tokenDetails: 'details',
+    divisible: true,
+    treasuryWallet: myAddress,
+    protocolVersion: '0',
+  });
+
+  console.log('Security Token Generated');
+
+  const moduleName = ModuleName.BlacklistTransferManager;
+
+  const modules = await polymathAPI.moduleRegistry.getModulesByType({
+    moduleType: ModuleType.TransferManager,
+  });
+
+  const instances: Promise<ModuleFactoryWrapper>[] = [];
+  modules.map(address => {
+    instances.push(polymathAPI.moduleFactory.getModuleFactory(address));
+  });
+  const resultInstances = await Promise.all(instances);
+
+  const names: Promise<string>[] = [];
+  resultInstances.map(instanceFactory => {
+    names.push(instanceFactory.name());
+  });
+  const resultNames = await Promise.all(names);
+
+  const index = resultNames.indexOf(moduleName);
+
+  // Create a Security Token Instance
+  const tickerSecurityTokenInstance = await polymathAPI.tokenFactory.getSecurityTokenInstanceFromTicker(ticker!);
+
+  // Get General TM Address to whitelist transfers
+  const generalTMAddress = (await tickerSecurityTokenInstance.getModulesByName({
+    moduleName: ModuleName.GeneralTransferManager,
+  }))[0];
+  const generalTM = await polymathAPI.moduleFactory.getModuleInstance({
+    name: ModuleName.GeneralTransferManager,
+    address: generalTMAddress,
+  });
+
+  await tickerSecurityTokenInstance.addModule({
+    moduleName,
+    address: modules[index],
+    archived: false,
+  });
+
+  const blacklistTMAddress = (await tickerSecurityTokenInstance.getModulesByName({
+    moduleName: ModuleName.BlacklistTransferManager,
+  }))[0];
+
+  const blacklistTM = await polymathAPI.moduleFactory.getModuleInstance({
+    name: ModuleName.BlacklistTransferManager,
+    address: blacklistTMAddress,
+  });
+
+  const randomBeneficiary1 = '0x2222222222222222222222222222222222222222';
+  const randomBeneficiary2 = '0x3333333333333333333333333333333333333333';
+
+  await generalTM.modifyKYCDataMulti({
+    investors: [myAddress, randomBeneficiary1, randomBeneficiary2],
+    canReceiveAfter: [new Date(), new Date(), new Date()],
+    canSendAfter: [new Date(), new Date(), new Date()],
+    expiryTime: [new Date(2035, 1), new Date(2035, 1), new Date(2035, 1)],
+  });
+
+  await tickerSecurityTokenInstance.issueMulti({
+    investors: [myAddress, randomBeneficiary1, randomBeneficiary2],
+    values: [new BigNumber(100), new BigNumber(100), new BigNumber(100)],
+  });
+
+  // Subscribe to event of addblacklisttype
+  await blacklistTM.subscribeAsync({
+    eventName: BlacklistTransferManagerEvents.AddBlacklistType,
+    indexFilterValues: {},
+    callback: async (error, log) => {
+      if (error) {
+        console.log(error);
+      } else {
+        console.log('New Lock Up added to user', log);
+      }
+    },
+  });
+
+  await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
+  console.log(' No blacklist, 10 tokens transferred to randomBeneficiary2');
+
+  const startTime = new Date(Date.now() + 10000);
+  const endTime = new Date(Date.now() + 20000);
+  await blacklistTM.addInvestorToNewBlacklist({
+    investor: myAddress,
+    startTime,
+    endTime,
+    repeatPeriodTime: 1,
+    blacklistName: 'ExampleBlacklist',
+  });
+
+  console.log('Blacklist starts in 10 seconds');
+  const sleep = (milliseconds: number) => {
+    console.log(`Sleeping ${milliseconds / 1000} seconds`);
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+  };
+  await sleep(15000);
+
+  // Try out transfer 10 above lockup, will fail
+  try {
+    await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
+  } catch (e) {
+    console.log('Transfer of 10 tokens during blacklist period amount fails as expected');
+  }
+
+  console.log('Blacklist ends in 5 seconds');
+  await sleep(10000);
+
+  // Blacklist now over
+  await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
+  console.log('10 more tokens transferred to randomBeneficiary2');
+
+  const newStartTime = new Date(Date.now() + 10000);
+  const newEndTime = new Date(Date.now() + 3600000);
+  const testBlacklistNames = ['TestBlacklist1', 'TestBlacklist2', 'TestBlacklist3'];
+  await blacklistTM.addNewBlacklistTypeMulti({
+    blacklistNames: testBlacklistNames,
+    startTimes: [newStartTime, newStartTime, newStartTime],
+    endTimes: [newEndTime, newEndTime, newEndTime],
+    repeatPeriodTimes: [1, 2, 3]
+  });
+  console.log('Many more example blacklists created');
+
+  await blacklistTM.addMultiInvestorToBlacklistMulti({blacklistNames: testBlacklistNames, userAddresses: [myAddress, randomBeneficiary1, randomBeneficiary2]});
+  console.log('Multi investors added to multi blacklists');
+
+  await sleep(15000);
+
+  // Try out transfer 10 during blacklist, will fail
+  try {
+    await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
+  } catch (e) {
+    console.log('Transfer of 10 tokens during new blacklist period amount fails as expected');
+  }
+
+  await blacklistTM.deleteInvestorFromAllBlacklistMulti({investors: [myAddress, randomBeneficiary1, randomBeneficiary2]});
+  console.log('Multi investors deleted from all blacklists they are part of');
+
+  // Transfer out more tokens now that the investor has been removed from the new blacklist
+  await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
+  console.log('10 more tokens were successfully transferred to randomBeneficiary2');
+
+  tickerSecurityTokenInstance.unsubscribeAll();
+});

examples/lockUpTransferManager.ts

@@ -141,8 +141,8 @@ window.addEventListener('load', async () => {
   await lockUpTM.addNewLockUpToUserMulti({
     userAddresses: [myAddress, randomBeneficiary1, randomBeneficiary2],
     startTimes: [new Date(2030, 1, 1), new Date(2030, 1, 1), new Date(2030, 1, 1)],
-    lockUpPeriodSeconds: [new BigNumber(5), new BigNumber(5), new BigNumber(5)],
-    releaseFrequenciesSeconds: [new BigNumber(1), new BigNumber(1), new BigNumber(1)],
+    lockUpPeriodSeconds: [5, 5, 5],
+    releaseFrequenciesSeconds: [1, 1, 1],
     lockupAmounts: [new BigNumber(100), new BigNumber(100), new BigNumber(100)],
     lockupNames: [firstLockUpName, secondLockUpName, thirdLockUpName],
   });
@@ -171,8 +171,8 @@ window.addEventListener('load', async () => {
   // Modify the lockup types so that we can test in real time
   await lockUpTM.modifyLockUpTypeMulti({
     startTimes: [startTime, startTime, startTime],
-    lockUpPeriodSeconds: [new BigNumber(5), new BigNumber(5), new BigNumber(5)],
-    releaseFrequenciesSeconds: [new BigNumber(1), new BigNumber(1), new BigNumber(1)],
+    lockUpPeriodSeconds: [5, 5, 5],
+    releaseFrequenciesSeconds: [1, 1, 1],
     lockupAmounts: [new BigNumber(20), new BigNumber(10), new BigNumber(10)],
     lockupNames: [firstLockUpName, secondLockUpName, thirdLockUpName],
   });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymathnetwork/contract-wrappers",
-  "version": "2.0.0-beta.31",
+  "version": "2.0.0-beta.32",
   "description": "Smart TS wrappers for Polymath smart contracts",
   "keywords": [
     "polymath",

src/PolymathAPI.ts

@@ -4,26 +4,27 @@ import {
   BigNumber,
   providerUtils,
   Provider,
-  FeatureRegistryContract,
-  ModuleRegistryContract,
-  PolymathRegistryContract,
-  ISecurityTokenRegistryContract,
-  ModuleFactoryContract,
-  ModuleContract,
+  BlacklistTransferManagerContract,
+  CappedSTOContract,
+  CountTransferManagerContract,
+  ERC20DetailedContract,
   ERC20DividendCheckpointContract,
   EtherDividendCheckpointContract,
+  FeatureRegistryContract,
   GeneralPermissionManagerContract,
-  CappedSTOContract,
-  USDTieredSTOContract,
-  CountTransferManagerContract,
   GeneralTransferManagerContract,
+  ISecurityTokenContract,
+  ISecurityTokenRegistryContract,
+  LockUpTransferManagerContract,
   ManualApprovalTransferManagerContract,
+  ModuleContract,
+  ModuleFactoryContract,
+  ModuleRegistryContract,
   PercentageTransferManagerContract,
-  LockUpTransferManagerContract,
-  ERC20DetailedContract,
+  PolymathRegistryContract,
   PolyTokenContract,
   PolyTokenFaucetContract,
-  ISecurityTokenContract,
+  USDTieredSTOContract,
   VolumeRestrictionTMContract,
   VestingEscrowWalletContract,
 } from '@polymathnetwork/abi-wrappers';
@@ -158,6 +159,7 @@ export class PolymathAPI {
       ManualApprovalTransferManagerContract.ABI(),
       PercentageTransferManagerContract.ABI(),
       LockUpTransferManagerContract.ABI(),
+      BlacklistTransferManagerContract.ABI(),
       VolumeRestrictionTMContract.ABI(),
       // Tokens
       ERC20DetailedContract.ABI(),

src/contract_wrappers/modules/module_wrapper.ts

@@ -102,20 +102,16 @@ export default class ModuleWrapper extends ContractWrapper {
     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
+      // type '6' and '8' are valid but they are not mapped, so we must filter them
       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) {
+    // prevent invalid scenarios
+    if (!types.length || types.length > 1) {
       return false;
     }
     const address = await this.address();