feat: 🎸 add vesting escrow wallet example

add VEW example and fix some issues discovered in the process

Author: shuffledex

examples/percentageTransferManager.ts

@@ -1,9 +1,9 @@
 import { RedundantSubprovider, RPCSubprovider, Web3ProviderEngine } from '@0x/subproviders';
+import { BigNumber } from '@polymathnetwork/abi-wrappers';
 import ModuleFactoryWrapper from '../src/contract_wrappers/modules/module_factory_wrapper';
 import { ApiConstructorParams, PolymathAPI } from '../src/PolymathAPI';
 import { bytes32ToString } from '../src/utils/convert';
 import { ModuleName, ModuleType } from '../src';
-import { BigNumber } from '@polymathnetwork/abi-wrappers';
 
 // This file acts as a valid sandbox for using a percentage restriction transfer manager module on an unlocked node (like ganache)
 window.addEventListener('load', async () => {
@@ -40,11 +40,7 @@ window.addEventListener('load', async () => {
     names.push(instanceFactory.name());
   });
   const resultNames = await Promise.all(names);
-
-  const finalNames = resultNames.map(name => {
-    return bytes32ToString(name);
-  });
-  const index = finalNames.indexOf(moduleStringName);
+  const index = resultNames.indexOf(moduleStringName);
 
   // Call to add module
   await tickerSecurityTokenInstance.addModule({

examples/vestingEscrowWallet.ts

@@ -0,0 +1,174 @@
+import { RedundantSubprovider, RPCSubprovider, Web3ProviderEngine } from '@0x/subproviders';
+import { BigNumber } from '@polymathnetwork/abi-wrappers';
+import { ApiConstructorParams, PolymathAPI } from '../src/PolymathAPI';
+import { ModuleName, ModuleType } from '../src';
+import ModuleFactoryWrapper from '../src/contract_wrappers/modules/module_factory_wrapper';
+
+// This file acts as a valid sandbox.ts file in root directory for adding a new Vesting Escrow Wallet module
+
+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.isTickerAvailable({
+    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,
+  });
+
+  // Generate a security token
+  await polymathAPI.securityTokenRegistry.generateNewSecurityToken({
+    name: tokenName!,
+    ticker: ticker!,
+    tokenDetails: 'http://',
+    divisible: false,
+    treasuryWallet: myAddress,
+    protocolVersion: '0',
+  });
+
+  // Create a Security Token Instance
+  const tickerSecurityTokenInstance = await polymathAPI.tokenFactory.getSecurityTokenInstanceFromTicker(ticker!);
+  console.log('ST address:', await tickerSecurityTokenInstance.address());
+
+  // Get permission manager factory address
+  const moduleStringName = 'VestingEscrowWallet';
+  const moduleName = ModuleName.VestingEscrowWallet;
+
+  const modules = await polymathAPI.moduleRegistry.getModulesByType({
+    moduleType: ModuleType.Wallet,
+  });
+
+  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(moduleStringName);
+
+  const factory = await polymathAPI.moduleFactory.getModuleFactory(modules[index]);
+  const setupCost = await factory.setupCostInPoly();
+
+  // Call to add count transfer manager module
+  await tickerSecurityTokenInstance.addModule({
+    moduleName,
+    address: modules[index],
+    maxCost: setupCost,
+    budget: setupCost,
+    archived: false,
+    data: {
+      treasuryWallet: '0x2320351c4670a19C3DD05789d2648DD129A14669',
+    },
+  });
+
+  const VEWAddress = (await tickerSecurityTokenInstance.getModulesByName({
+    moduleName: ModuleName.VestingEscrowWallet,
+  }))[0];
+  const VEW = await polymathAPI.moduleFactory.getModuleInstance({
+    name: ModuleName.VestingEscrowWallet,
+    address: VEWAddress,
+  });
+
+  const VEWModuleAddress = await VEW.address();
+  const numberOfTokens = 500;
+  const TEMPLATE_NAME = 'Test Template';
+  const beneficiary = '0x72aF7849ffc7753B5ccEA5cb80F97e9Aeaf7d999';
+
+  const generalTMAddress = (await tickerSecurityTokenInstance.getModulesByName({
+    moduleName: ModuleName.GeneralTransferManager,
+  }))[0];
+
+  const generalTM = await polymathAPI.moduleFactory.getModuleInstance({
+    name: ModuleName.GeneralTransferManager,
+    address: generalTMAddress,
+  });
+
+  // Add owner address in the whitelist to allow mint tokens
+  await generalTM.modifyKYCData({
+    investor: myAddress,
+    canSendAfter: new Date(2019, 7),
+    canReceiveAfter: new Date(2019, 7),
+    expiryTime: new Date(2020, 1),
+    txData: {
+      from: await polymathAPI.getAccount(),
+    },
+  });
+
+  // Mint yourself some tokens and make some transfers
+  await tickerSecurityTokenInstance.issue({
+    investor: myAddress,
+    value: new BigNumber(100000),
+  });
+
+  // Add VEW module in the whitelist (remove this on 3.1 release)
+  await generalTM.modifyKYCData({
+    investor: VEWModuleAddress,
+    canSendAfter: new Date(2019, 7),
+    canReceiveAfter: new Date(2019, 7),
+    expiryTime: new Date(2020, 1),
+    txData: {
+      from: await polymathAPI.getAccount(),
+    },
+  });
+
+  // Add Template
+  await VEW.addTemplate({
+    name: TEMPLATE_NAME,
+    numberOfTokens,
+    duration: 100,
+    frequency: 10,
+  });
+
+  await tickerSecurityTokenInstance.approve({
+    spender: VEWModuleAddress,
+    value: new BigNumber(numberOfTokens),
+  });
+
+  // Add Schedule
+  await VEW.addScheduleFromTemplate({
+    beneficiary,
+    templateName: TEMPLATE_NAME,
+    startTime: new Date(new Date().getTime() + 1 * 60000),
+  });
+});

src/contract_wrappers/modules/wallet/__tests__

@@ -34,6 +34,7 @@ import {
   TransferResult,
   Perm,
   TransferStatusCode,
+  FULL_DECIMALS,
 } from '../../../types';
 import {
   numberToBigNumber,
@@ -43,6 +44,7 @@ import {
   bytes32ToString,
   bytes32ArrayToStringArray,
   bigNumberToDate,
+  stringToBytes32,
 } from '../../../utils/convert';
 
 const TRANSFER_SUCCESS = '0x51';
@@ -442,7 +444,8 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
   };
 
   public unassignedTokens = async () => {
-    return (await this.contract).unassignedTokens.callAsync();
+    const result = await (await this.contract).unassignedTokens.callAsync();
+    return result.toNumber();
   };
 
   public schedules = async (params: SchedulesParams) => {
@@ -484,13 +487,13 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     const canTransferFromResult = await (await this.securityTokenContract()).canTransferFrom.callAsync(
       await this.getCallerAddress(params.txData),
       await this.address(),
-      numberToBigNumber(params.numberOfTokens),
+      valueToWei(numberToBigNumber(params.numberOfTokens), FULL_DECIMALS),
       '0x00',
     );
     assert.assert(canTransferFromResult[0] === TRANSFER_SUCCESS, 'Failed transferFrom');
 
     return (await this.contract).depositTokens.sendTransactionAsync(
-      numberToBigNumber(params.numberOfTokens),
+      valueToWei(numberToBigNumber(params.numberOfTokens), FULL_DECIMALS),
       params.txData,
       params.safetyFactor,
     );
@@ -503,7 +506,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
     assert.assert(params.amount > 0, 'Amount cannot be zero');
 
-    const unassignedTokens = (await this.unassignedTokens()).toNumber();
+    const unassignedTokens = await this.unassignedTokens();
     assert.assert(params.amount <= unassignedTokens, 'Amount is greater than unassigned tokens');
 
     const canTransferResult = await (await this.securityTokenContract()).canTransfer.callAsync(
@@ -557,8 +560,8 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     assert.assert(!(await this.getAllTemplateNames()).includes(params.name), 'Template name already exists');
     await this.validateTemplate(params.numberOfTokens, params.duration, params.frequency);
     return (await this.contract).addTemplate.sendTransactionAsync(
-      params.name,
-      numberToBigNumber(params.numberOfTokens),
+      stringToBytes32(params.name),
+      valueToWei(numberToBigNumber(params.numberOfTokens), FULL_DECIMALS),
       numberToBigNumber(params.duration),
       numberToBigNumber(params.frequency),
       params.txData,
@@ -603,11 +606,11 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     assert.assert(params.templateName !== '', 'Invalid name');
     assert.assert(!(await this.getAllTemplateNames()).includes(params.templateName), 'Template name already exists');
     await this.validateTemplate(params.numberOfTokens, params.duration, params.frequency);
-    await this.validateAddScheduleFromTemplate(params.beneficiary, params.templateName, params.startTime);
+    await this.validateAddSchedule(params.beneficiary, params.templateName, params.startTime);
     return (await this.contract).addSchedule.sendTransactionAsync(
       params.beneficiary,
-      params.templateName,
-      numberToBigNumber(params.numberOfTokens),
+      stringToBytes32(params.templateName),
+      valueToWei(numberToBigNumber(params.numberOfTokens), FULL_DECIMALS),
       numberToBigNumber(params.duration),
       numberToBigNumber(params.frequency),
       dateToBigNumber(params.startTime),
@@ -624,7 +627,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     await this.validateAddScheduleFromTemplate(params.beneficiary, params.templateName, params.startTime);
     return (await this.contract).addScheduleFromTemplate.sendTransactionAsync(
       params.beneficiary,
-      params.templateName,
+      stringToBytes32(params.templateName),
       dateToBigNumber(params.startTime),
       params.txData,
       params.safetyFactor,
@@ -641,7 +644,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     // TODO: require(now < schedule.startTime, "Schedule started");
     return (await this.contract).modifySchedule.sendTransactionAsync(
       params.beneficiary,
-      params.templateName,
+      stringToBytes32(params.templateName),
       dateToBigNumber(params.startTime),
       params.txData,
       params.safetyFactor,
@@ -657,7 +660,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     // TODO: _sendTokensPerSchedule assert
     return (await this.contract).revokeSchedule.sendTransactionAsync(
       params.beneficiary,
-      params.templateName,
+      stringToBytes32(params.templateName),
       params.txData,
       params.safetyFactor,
     );
@@ -683,6 +686,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
   public getSchedule = async (params: GetScheduleParams) => {
     this.checkSchedule(params.beneficiary, params.templateName);
     const result = await (await this.contract).getSchedule.callAsync(params.beneficiary, params.templateName);
+
     return {
       numberOfTokens: result[0].toNumber(),
       duration: result[1].toNumber(),
@@ -710,7 +714,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
   public getScheduleCount = async (params: GetScheduleCountParams) => {
     assert.isNonZeroETHAddressHex('beneficiary', params.beneficiary);
     const result = await (await this.contract).getScheduleCount.callAsync(params.beneficiary);
-    return result.toNumber();
+    return weiToValue(result, FULL_DECIMALS).toNumber();
   };
 
   /**
@@ -751,7 +755,7 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
         this.validateTemplate(params.numberOfTokens[i], params.durations[i], params.frequencies[i]),
       );
       resultValidateAddScheduleFromTemplate.push(
-        this.validateAddScheduleFromTemplate(params.beneficiaries[i], params.templateNames[i], params.startTimes[i]),
+        this.validateAddSchedule(params.beneficiaries[i], params.templateNames[i], params.startTimes[i]),
       );
     }
     const getAllTemplatesNames = await Promise.all(resultGetAllTemplatesNames);
@@ -763,9 +767,11 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
 
     return (await this.contract).addScheduleMulti.sendTransactionAsync(
       params.beneficiaries,
-      params.templateNames,
+      params.templateNames.map(name => {
+        return stringToBytes32(name);
+      }),
       params.numberOfTokens.map(number => {
-        return numberToBigNumber(number);
+        return valueToWei(numberToBigNumber(number), FULL_DECIMALS);
       }),
       params.durations.map(duration => {
         return numberToBigNumber(duration);
@@ -795,7 +801,9 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     await Promise.all(resultsValidateAddScheduleFromTemplate);
     return (await this.contract).addScheduleFromTemplateMulti.sendTransactionAsync(
       params.beneficiaries,
-      params.templateNames,
+      params.templateNames.map(name => {
+        return stringToBytes32(name);
+      }),
       params.startTimes.map(startTime => {
         return dateToBigNumber(startTime);
       }),
@@ -837,7 +845,9 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
 
     return (await this.contract).modifyScheduleMulti.sendTransactionAsync(
       params.beneficiaries,
-      params.templateNames,
+      params.templateNames.map(name => {
+        return stringToBytes32(name);
+      }),
       params.startTimes.map(startTime => {
         return dateToBigNumber(startTime);
       }),
@@ -853,7 +863,13 @@ export default class VestingEscrowWalletWrapper extends ModuleWrapper {
     assert.assert(numberOfTokens % periodCount === 0, 'Invalid period count');
     const amountPerPeriod = numberOfTokens / periodCount;
     const granularity = await (await this.securityTokenContract()).granularity.callAsync();
-    assert.assert(amountPerPeriod % granularity.toNumber() === 0, 'Invalid granularity');
+    assert.assert(amountPerPeriod % weiToValue(granularity, FULL_DECIMALS).toNumber() === 0, 'Invalid granularity');
+  };
+
+  private validateAddSchedule = async (beneficiary: string, templateName: string, startTime: Date) => {
+    assert.isNonZeroETHAddressHex('beneficiary', beneficiary);
+    assert.assert((await this.getScheduleCount({ beneficiary })) === 0, 'Already added');
+    assert.assert(startTime.getTime() > Date.now(), 'Date in the past');
   };
 
   private validateAddScheduleFromTemplate = async (beneficiary: string, templateName: string, startTime: Date) => {