fix: 🐛 add VEW event args and adapt it to new abi refactor

Add VEW EventArgs on types.ts and adapt the wrapper to the new ABI
structure

Author: shuffledex

.eslintrc.js

@@ -24,6 +24,7 @@ module.exports = {
     'jest/expect-expect': 'error',
     'jest/no-empty-title': 'warn',
     'jest/no-truthy-falsy': 'warn',
+    'import/prefer-default-export': 'off',
   },
   settings: {
     'import/resolver': {

examples/lockUpTransferManager.ts

@@ -1,8 +1,8 @@
 import { RedundantSubprovider, RPCSubprovider, Web3ProviderEngine } from '@0x/subproviders';
+import { BigNumber, LockUpTransferManagerEvents } from '@polymathnetwork/abi-wrappers';
 import ModuleFactoryWrapper from '../src/contract_wrappers/modules/module_factory_wrapper';
 import { ApiConstructorParams, PolymathAPI } from '../src/PolymathAPI';
 import { ModuleName, ModuleType } from '../src';
-import { BigNumber, ModuleRegistryEvents, LockUpTransferManagerEvents } from '@polymathnetwork/abi-wrappers';
 
 // This file acts as a valid sandbox for using a lockup restriction transfer manager module on an unlocked node (like ganache)
 window.addEventListener('load', async () => {
@@ -27,7 +27,7 @@ window.addEventListener('load', async () => {
   const tokenName = prompt('Token Name', '');
 
   // Double check available
-  await polymathAPI.securityTokenRegistry.isTickerAvailable({
+  await polymathAPI.securityTokenRegistry.tickerAvailable({
     ticker: ticker!,
   });
   // Get the ticker fee and approve the security token registry to spend
@@ -191,7 +191,7 @@ window.addEventListener('load', async () => {
   });
   // Example removing lockup from beneficiary 2 and removing lockup type
   await lockUpTM.removeLockUpFromUser({ userAddress: randomBeneficiary2, lockupName: thirdLockUpName });
-  await lockUpTM.removeLockupType({lockupName: thirdLockUpName});
+  await lockUpTM.removeLockupType({ lockupName: thirdLockUpName });
 
   // Try to transfer 50, it is below lockup and will pass
   await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(50) });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymathnetwork/contract-wrappers",
-  "version": "2.0.0-beta.27",
+  "version": "2.0.0-beta.30",
   "description": "Smart TS wrappers for Polymath smart contracts",
   "keywords": [
     "polymath",
@@ -84,7 +84,7 @@
     "@0x/subproviders": "^4.1.1",
     "@0x/types": "^2.4.0",
     "@0x/typescript-typings": "^4.2.3",
-    "@polymathnetwork/abi-wrappers": "3.0.0-beta.7",
+    "@polymathnetwork/abi-wrappers": "3.0.0-beta.8",
     "@types/semver": "^6.0.1",
     "ethereumjs-blockstream": "6.0.0",
     "ethereumjs-util": "^6.1.0",

src/PolymathAPI.ts

@@ -4,30 +4,28 @@ import {
   BigNumber,
   providerUtils,
   Provider,
-  PolymathRegistry,
-  ISecurityTokenRegistry,
-  ISecurityToken,
-  PolyToken,
-  ModuleRegistry,
-  CappedSTO,
-  ModuleFactory,
-  USDTieredSTO,
-  FeatureRegistry,
-  GeneralTransferManager,
-  GeneralPermissionManager,
-  ERC20DividendCheckpoint,
-  ManualApprovalTransferManager,
-  CountTransferManager,
-  PercentageTransferManager,
-  LockUpTransferManager,
-  EtherDividendCheckpoint,
-  VolumeRestrictionTransferManager,
-  PolyTokenFaucet,
-  Module,
-  ERC20Detailed,
-  VestingEscrowWallet,
+  FeatureRegistryContract,
+  ModuleRegistryContract,
+  PolymathRegistryContract,
+  ISecurityTokenRegistryContract,
+  ModuleFactoryContract,
+  ModuleContract,
+  ERC20DividendCheckpointContract,
+  EtherDividendCheckpointContract,
+  GeneralPermissionManagerContract,
+  CappedSTOContract,
+  USDTieredSTOContract,
+  CountTransferManagerContract,
+  GeneralTransferManagerContract,
+  ManualApprovalTransferManagerContract,
+  PercentageTransferManagerContract,
+  LockUpTransferManagerContract,
+  ERC20DetailedContract,
+  PolyTokenContract,
+  PolyTokenFaucetContract,
+  ISecurityTokenContract,
+  VolumeRestrictionTMContract,
 } from '@polymathnetwork/abi-wrappers';
-import _ from 'lodash';
 import PolymathRegistryWrapper from './contract_wrappers/registries/polymath_registry_wrapper';
 import SecurityTokenRegistryWrapper from './contract_wrappers/registries/security_token_registry_wrapper';
 import PolyTokenWrapper from './contract_wrappers/tokens/poly_token_wrapper';
@@ -138,62 +136,33 @@ export class PolymathAPI {
 
     const abiArray = [
       // Registries
-      FeatureRegistry.abi,
-      ModuleRegistry.abi.filter(
-        a =>
-          !(
-            a.type === 'function' &&
-            a.name === 'useModule' &&
-            _.isEqual(a.inputs, [
-              {
-                name: '_moduleFactory',
-                type: 'address',
-              },
-            ])
-          ),
-      ),
-      PolymathRegistry.abi,
-      ISecurityTokenRegistry.abi.filter(
-        a =>
-          !(
-            a.type === 'event' &&
-            a.name === 'RegisterTicker' &&
-            _.isEqual(a.inputs, [
-              { indexed: true, name: '_owner', type: 'address' },
-              { indexed: false, name: '_ticker', type: 'string' },
-              { indexed: false, name: '_name', type: 'string' },
-              { indexed: true, name: '_registrationDate', type: 'uint256' },
-              { indexed: true, name: '_expiryDate', type: 'uint256' },
-              { indexed: false, name: '_fromAdmin', type: 'bool' },
-              { indexed: false, name: '_registrationFee', type: 'uint256' },
-            ])
-          ),
-      ),
+      FeatureRegistryContract.ABI(),
+      ModuleRegistryContract.ABI(),
+      PolymathRegistryContract.ABI(),
+      ISecurityTokenRegistryContract.ABI(),
       // Modules
-      ModuleFactory.abi,
-      Module.abi,
+      ModuleFactoryContract.ABI(),
+      ModuleContract.ABI(),
       // Checkpoint
-      ERC20DividendCheckpoint.abi,
-      EtherDividendCheckpoint.abi,
+      ERC20DividendCheckpointContract.ABI(),
+      EtherDividendCheckpointContract.ABI(),
       // Permission
-      GeneralPermissionManager.abi,
+      GeneralPermissionManagerContract.ABI(),
       // STO
-      CappedSTO.abi,
-      USDTieredSTO.abi,
+      CappedSTOContract.ABI(),
+      USDTieredSTOContract.ABI(),
       // Transfer
-      CountTransferManager.abi,
-      GeneralTransferManager.abi,
-      ManualApprovalTransferManager.abi,
-      PercentageTransferManager.abi,
-      LockUpTransferManager.abi,
-      VolumeRestrictionTransferManager.abi,
+      CountTransferManagerContract.ABI(),
+      GeneralTransferManagerContract.ABI(),
+      ManualApprovalTransferManagerContract.ABI(),
+      PercentageTransferManagerContract.ABI(),
+      LockUpTransferManagerContract.ABI(),
+      VolumeRestrictionTMContract.ABI(),
       // Tokens
-      ERC20Detailed.abi,
-      PolyToken.abi,
-      PolyTokenFaucet.abi,
-      ISecurityToken.abi,
-      // Wallet
-      VestingEscrowWallet.abi,
+      ERC20DetailedContract.ABI(),
+      PolyTokenContract.ABI(),
+      PolyTokenFaucetContract.ABI(),
+      ISecurityTokenContract.ABI(),
     ];
 
     abiArray.forEach((abi): void => {

src/contract_wrappers/contract_wrapper.ts

@@ -1,11 +1,11 @@
 /* eslint-disable no-underscore-dangle */
 import { Block, BlockAndLogStreamer, Log } from 'ethereumjs-blockstream';
 import _ from 'lodash';
+import { schemas } from '@0x/json-schemas';
 import {
   BaseContract,
   Web3Wrapper,
   marshaller,
-  AbiDecoder,
   intervalUtils,
   logUtils,
   BlockParamLiteral,
@@ -33,8 +33,6 @@ const SUBSCRIPTION_NOT_FOUND = 'SUBSCRIPTION_NOT_FOUND';
 const SUBSCRIPTION_ALREADY_PRESENT = 'SUBSCRIPTION_ALREADY_PRESENT';
 
 export default abstract class ContractWrapper {
-  public abstract abi: ContractAbi;
-
   protected contract: Promise<BaseContract>;
 
   protected web3Wrapper: Web3Wrapper;
@@ -43,6 +41,13 @@ export default abstract class ContractWrapper {
 
   public abstract subscribeAsync: Subscribe | undefined;
 
+  /**
+   * Returns the contract ABI
+   */
+  public abi = async (): Promise<ContractAbi> => {
+    return (await this.contract).abi;
+  };
+
   /**
    * Returns the contract address
    */
@@ -64,12 +69,9 @@ export default abstract class ContractWrapper {
    */
   public unsubscribeAll = (): void => {
     const filterTokens = _.keys(this._filterCallbacks);
-    _.each(
-      filterTokens,
-      (filterToken): void => {
-        this.unsubscribeInternal(filterToken);
-      },
-    );
+    _.each(filterTokens, (filterToken): void => {
+      this.unsubscribeInternal(filterToken);
+    });
   };
 
   private _blockAndLogStreamerIfExists: BlockAndLogStreamer<Block, Log> | undefined;
@@ -117,14 +119,14 @@ export default abstract class ContractWrapper {
     }
   }
 
-  protected subscribeInternal<ArgsType extends ContractEventArgs>(
+  protected async subscribeInternal<ArgsType extends ContractEventArgs>(
     address: string,
     eventName: ContractEvents,
     indexFilterValues: IndexedFilterValues,
-    abi: ContractAbi,
     callback: EventCallback<ArgsType>,
     isVerbose: boolean = false,
-  ): string {
+  ): Promise<string> {
+    const { abi } = await this.contract;
     const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi);
     if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
       this._startBlockAndLogStream(isVerbose);
@@ -138,11 +140,18 @@ export default abstract class ContractWrapper {
   protected async getLogsAsyncInternal<ArgsType extends ContractEventArgs>(
     address: string,
     eventName: ContractEvents,
-    blockRange: BlockRange,
-    indexFilterValues: IndexedFilterValues,
-    abi: ContractAbi,
+    blockRange?: BlockRange,
+    indexFilterValues?: IndexedFilterValues,
   ): Promise<LogWithDecodedArgs<ArgsType>[]> {
-    const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi, blockRange);
+    const { abi } = await this.contract;
+    const _blockRange = blockRange || {
+      fromBlock: BlockParamLiteral.Earliest,
+      toBlock: BlockParamLiteral.Latest,
+    };
+    const _indexFilterValues = indexFilterValues || {};
+    assert.doesConformToSchema('blockRange', _blockRange, schemas.blockRangeSchema);
+    assert.doesConformToSchema('indexFilterValues', _indexFilterValues, schemas.indexFilterValuesSchema);
+    const filter = filterUtils.getFilter(address, eventName, _indexFilterValues, abi, _blockRange);
     const logs = await this.web3Wrapper.getLogsAsync(filter);
     const logsWithDecodedArguments = _.map(logs, this.tryToDecodeLogOrNoopInternal.bind(this));
     return logsWithDecodedArguments as LogWithDecodedArgs<ArgsType>[];
@@ -151,26 +160,23 @@ export default abstract class ContractWrapper {
   protected tryToDecodeLogOrNoopInternal<ArgsType extends ContractEventArgs>(
     log: LogEntry,
   ): LogWithDecodedArgs<ArgsType> | RawLog {
-    const abiDecoder = new AbiDecoder([this.abi]);
+    const { abiDecoder } = this.web3Wrapper;
     const logWithDecodedArgs = abiDecoder.tryToDecodeLogOrNoop(log);
     return logWithDecodedArgs;
   }
 
   private _onLogStateChanged<ArgsType extends ContractEventArgs>(isRemoved: boolean, rawLog: Log): void {
     const log: LogEntry = marshaller.unmarshalLog(rawLog as RawLogEntry);
-    _.forEach(
-      this._filters,
-      (filter: FilterObject, filterToken: string): void => {
-        if (filterUtils.matchesFilter(log, filter)) {
-          const decodedLog = this.tryToDecodeLogOrNoopInternal(log) as LogWithDecodedArgs<ArgsType>;
-          const logEvent = {
-            log: decodedLog,
-            isRemoved,
-          };
-          this._filterCallbacks[filterToken](null, logEvent);
-        }
-      },
-    );
+    _.forEach(this._filters, (filter: FilterObject, filterToken: string): void => {
+      if (filterUtils.matchesFilter(log, filter)) {
+        const decodedLog = this.tryToDecodeLogOrNoopInternal(log) as LogWithDecodedArgs<ArgsType>;
+        const logEvent = {
+          log: decodedLog,
+          isRemoved,
+        };
+        this._filterCallbacks[filterToken](null, logEvent);
+      }
+    });
   }
 
   private _startBlockAndLogStream(isVerbose: boolean): void {

src/contract_wrappers/modules/checkpoint/erc20_dividend_checkpoint_wrapper.ts

@@ -11,11 +11,8 @@ import {
   ERC20DividendCheckpointSetWithholdingFixedEventArgs,
   ERC20DetailedContract,
   BigNumber,
-  ContractAbi,
   LogWithDecodedArgs,
-  TxData,
   Web3Wrapper,
-  ERC20DividendCheckpoint,
 } from '@polymathnetwork/abi-wrappers';
 import { schemas } from '@0x/json-schemas';
 import assert from '../../../utils/assert';
@@ -32,8 +29,6 @@ import {
 } from '../../../types';
 import { numberToBigNumber, dateToBigNumber, stringToBytes32, valueToWei } from '../../../utils/convert';
 
-const EXCLUDED_ADDRESS_LIMIT = 150;
-
 interface ERC20DividendDepositedSubscribeAsyncParams extends SubscribeAsyncParams {
   eventName: ERC20DividendCheckpointEvents.ERC20DividendDeposited;
   callback: EventCallback<ERC20DividendCheckpointERC20DividendDepositedEventArgs>;
@@ -160,8 +155,6 @@ interface CreateDividendWithCheckpointAndExclusionsParams extends CreateDividend
  * This class includes the functionality related to interacting with the ERC20DividendCheckpoint contract.
  */
 export default class ERC20DividendCheckpointWrapper extends DividendCheckpointWrapper {
-  public abi: ContractAbi = ERC20DividendCheckpoint.abi;
-
   protected contract: Promise<ERC20DividendCheckpointContract>;
 
   protected erc20DetailedContract = async (address: string): Promise<ERC20DetailedContract> => {
@@ -307,11 +300,10 @@ export default class ERC20DividendCheckpointWrapper extends DividendCheckpointWr
     assert.doesConformToSchema('indexFilterValues', params.indexFilterValues, schemas.indexFilterValuesSchema);
     assert.isFunction('callback', params.callback);
     const normalizedContractAddress = (await this.contract).address.toLowerCase();
-    const subscriptionToken = this.subscribeInternal<ArgsType>(
+    const subscriptionToken = await this.subscribeInternal<ArgsType>(
       normalizedContractAddress,
       params.eventName,
       params.indexFilterValues,
-      ERC20DividendCheckpoint.abi,
       params.callback,
       params.isVerbose,
     );
@@ -328,15 +320,12 @@ export default class ERC20DividendCheckpointWrapper extends DividendCheckpointWr
     params: GetLogsAsyncParams,
   ): Promise<LogWithDecodedArgs<ArgsType>[]> => {
     assert.doesBelongToStringEnum('eventName', params.eventName, ERC20DividendCheckpointEvents);
-    assert.doesConformToSchema('blockRange', params.blockRange, schemas.blockRangeSchema);
-    assert.doesConformToSchema('indexFilterValues', params.indexFilterValues, schemas.indexFilterValuesSchema);
     const normalizedContractAddress = (await this.contract).address.toLowerCase();
     const logs = await this.getLogsAsyncInternal<ArgsType>(
       normalizedContractAddress,
       params.eventName,
       params.blockRange,
       params.indexFilterValues,
-      ERC20DividendCheckpoint.abi,
     );
     return logs;
   };