fix: 🐛 implement ErrorCode type for dividend checkpoint wrapper

Author: shuffledex

src/contract_wrappers/modules/checkpoint/dividend_checkpoint_wrapper.ts

@@ -1,7 +1,7 @@
 import { BigNumber, TxData, ERC20DetailedContract } from '@polymathnetwork/abi-wrappers';
 import ModuleWrapper from '../module_wrapper';
 import assert from '../../../utils/assert';
-import { TxParams, DividendCheckpointBaseContract, Perm, PERCENTAGE_DECIMALS } from '../../../types';
+import { TxParams, DividendCheckpointBaseContract, Perm, PERCENTAGE_DECIMALS, ErrorCode } from '../../../types';
 import {
   numberToBigNumber,
   dateToBigNumber,
@@ -207,20 +207,32 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public pause = async (params: TxParams) => {
-    assert.assert(!(await this.paused()), 'Contract currently paused');
-    assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'The caller must be the ST owner');
+    assert.assert(!(await this.paused()), ErrorCode.ContractPaused, 'Contract currently paused');
+    assert.assert(
+      await this.isCallerTheSecurityTokenOwner(params.txData),
+      ErrorCode.Unauthorized,
+      'The caller must be the ST owner',
+    );
     return (await this.contract).pause.sendTransactionAsync(params.txData, params.safetyFactor);
   };
 
   public unpause = async (params: TxParams) => {
-    assert.assert(await this.paused(), 'Contract currently not paused');
-    assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'The caller must be the ST owner');
+    assert.assert(await this.paused(), ErrorCode.PreconditionRequired, 'Contract currently not paused');
+    assert.assert(
+      await this.isCallerTheSecurityTokenOwner(params.txData),
+      ErrorCode.Unauthorized,
+      'The caller must be the ST owner',
+    );
     return (await this.contract).unpause.sendTransactionAsync(params.txData, params.safetyFactor);
   };
 
   public changeWallet = async (params: ChangeWalletParams) => {
     assert.isNonZeroETHAddressHex('wallet', params.wallet);
-    assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'The caller must be the ST owner');
+    assert.assert(
+      await this.isCallerTheSecurityTokenOwner(params.txData),
+      ErrorCode.Unauthorized,
+      'The caller must be the ST owner',
+    );
     return (await this.contract).changeWallet.sendTransactionAsync(params.wallet, params.txData, params.safetyFactor);
   };
 
@@ -229,13 +241,25 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public createCheckpoint = async (params: TxParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Operator),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
     return (await this.contract).createCheckpoint.sendTransactionAsync(params.txData, params.safetyFactor);
   };
 
   public setDefaultExcluded = async (params: SetDefaultExcludedParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
-    assert.assert(params.excluded.length <= EXCLUDED_ADDRESS_LIMIT, 'Too many excluded addresses');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Admin),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
+    assert.assert(
+      params.excluded.length <= EXCLUDED_ADDRESS_LIMIT,
+      ErrorCode.InvalidData,
+      'Too many excluded addresses',
+    );
     params.excluded.forEach(address => assert.isNonZeroETHAddressHex('excluded', address));
     assert.areThereDuplicatedStrings('excluded', params.excluded);
     return (await this.contract).setDefaultExcluded.sendTransactionAsync(
@@ -246,8 +270,16 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public setWithholding = async (params: SetWithholdingParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
-    assert.assert(params.investors.length === params.withholding.length, 'Mismatched input lengths');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Admin),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
+    assert.assert(
+      params.investors.length === params.withholding.length,
+      ErrorCode.InvalidData,
+      'Mismatched input lengths',
+    );
     params.withholding.forEach(withholding => assert.isPercentage('withholding tax', withholding));
     return (await this.contract).setWithholding.sendTransactionAsync(
       params.investors,
@@ -258,7 +290,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public setWithholdingFixed = async (params: SetWithholdingFixedParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Admin),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
     assert.isPercentage('withholding tax', params.withholding);
     return (await this.contract).setWithholdingFixed.sendTransactionAsync(
       params.investors,
@@ -269,7 +305,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public pushDividendPaymentToAddresses = async (params: PushDividendPaymentToAddressesParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Operator),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
     params.payees.forEach(address => assert.isNonZeroETHAddressHex('payees', address));
     await this.checkValidDividend(params.dividendIndex);
     return (await this.contract).pushDividendPaymentToAddresses.sendTransactionAsync(
@@ -281,7 +321,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public pushDividendPayment = async (params: PushDividendPaymentParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Operator),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
     await this.checkValidDividend(params.dividendIndex);
     return (await this.contract).pushDividendPayment.sendTransactionAsync(
       numberToBigNumber(params.dividendIndex),
@@ -294,18 +338,18 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
 
   public pullDividendPayment = async (params: DividendIndexTxParams) => {
     await this.checkValidDividend(params.dividendIndex);
-    assert.assert(!(await this.paused()), 'Contract currently paused');
+    assert.assert(!(await this.paused()), ErrorCode.PreconditionRequired, 'Contract currently paused');
     const investor = await this.getCallerAddress(params.txData);
     const isClaimed = await (await this.contract).isClaimed.callAsync(
       investor,
       numberToBigNumber(params.dividendIndex),
     );
-    assert.assert(!isClaimed, `${investor} has already claimed this dividend`);
+    assert.assert(!isClaimed, ErrorCode.AlreadyClaimed, `${investor} has already claimed this dividend`);
     const isExcluded = await (await this.contract).isExcluded.callAsync(
       investor,
       numberToBigNumber(params.dividendIndex),
     );
-    assert.assert(!isExcluded, `${investor} is excluded from dividend`);
+    assert.assert(!isExcluded, ErrorCode.AddressExcluded, `${investor} is excluded from dividend`);
     return (await this.contract).pullDividendPayment.sendTransactionAsync(
       numberToBigNumber(params.dividendIndex),
       params.txData,
@@ -314,11 +358,19 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public reclaimDividend = async (params: DividendIndexTxParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Operator),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidData,
+      'Invalid dividend index',
+    );
     const dividend = await this.dividends(params);
     assert.isPastDate(dividend.expiry, 'Dividend expiry is in the future');
-    assert.assert(!dividend.reclaimed, 'Dividend is already claimed');
+    assert.assert(!dividend.reclaimed, ErrorCode.AlreadyClaimed, 'Dividend is already claimed');
     return (await this.contract).reclaimDividend.sendTransactionAsync(
       numberToBigNumber(params.dividendIndex),
       params.txData,
@@ -327,7 +379,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public calculateDividend = async (params: CalculateDividendParams) => {
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
     const result = await (await this.contract).calculateDividend.callAsync(
       numberToBigNumber(params.dividendIndex),
       params.payee,
@@ -345,8 +401,16 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public withdrawWithholding = async (params: DividendIndexTxParams) => {
-    assert.assert(await this.isCallerAllowed(params.txData, Perm.Operator), 'Caller is not allowed');
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isCallerAllowed(params.txData, Perm.Operator),
+      ErrorCode.Unauthorized,
+      'Caller is not allowed',
+    );
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
     return (await this.contract).withdrawWithholding.sendTransactionAsync(
       numberToBigNumber(params.dividendIndex),
       params.txData,
@@ -355,9 +419,17 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public updateDividendDates = async (params: UpdateDividendDatesParams) => {
-    assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'The caller must be the ST owner');
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
-    assert.assert(params.expiry > params.maturity, 'Expiry before maturity');
+    assert.assert(
+      await this.isCallerTheSecurityTokenOwner(params.txData),
+      ErrorCode.Unauthorized,
+      'The caller must be the ST owner',
+    );
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
+    assert.assert(params.expiry > params.maturity, ErrorCode.TooLate, 'Expiry before maturity');
     return (await this.contract).updateDividendDates.sendTransactionAsync(
       numberToBigNumber(params.dividendIndex),
       dateToBigNumber(params.maturity),
@@ -406,7 +478,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   public getDividendProgress = async (params: DividendIndexParams) => {
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
     const result = await (await this.contract).getDividendProgress.callAsync(numberToBigNumber(params.dividendIndex));
     const typedResult: Promise<DividendProgress>[] = [];
     for (let i = 0; i < result[0].length; i += 1) {
@@ -433,7 +509,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
 
   public getCheckpointData = async (params: CheckpointIdParams) => {
     const currentCheckpointId = await (await this.securityTokenContract()).currentCheckpointId.callAsync();
-    assert.assert(params.checkpointId <= new BigNumber(currentCheckpointId).toNumber(), 'Invalid checkpoint');
+    assert.assert(
+      params.checkpointId <= new BigNumber(currentCheckpointId).toNumber(),
+      ErrorCode.InvalidCheckpoint,
+      'Invalid checkpoint',
+    );
     const result = await (await this.contract).getCheckpointData.callAsync(numberToBigNumber(params.checkpointId));
     const typedResult: Promise<CheckpointData>[] = [];
     for (let i = 0; i < result[0].length; i += 1) {
@@ -456,13 +536,21 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
 
   public isClaimed = async (params: InvestorStatus) => {
     assert.isETHAddressHex('investor', params.investor);
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
     return (await this.contract).isClaimed.callAsync(params.investor, numberToBigNumber(params.dividendIndex));
   };
 
   public isExcluded = async (params: InvestorStatus) => {
     assert.isETHAddressHex('investor', params.investor);
-    assert.assert(await this.isValidDividendIndex(params.dividendIndex), 'Invalid dividend index');
+    assert.assert(
+      await this.isValidDividendIndex(params.dividendIndex),
+      ErrorCode.InvalidDividend,
+      'Invalid dividend index',
+    );
     return (await this.contract).isExcluded.callAsync(params.investor, numberToBigNumber(params.dividendIndex));
   };
 
@@ -472,10 +560,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   };
 
   private checkValidDividend = async (dividendIndex: number) => {
-    assert.assert(await this.isValidDividendIndex(dividendIndex), 'Invalid dividend index');
+    assert.assert(await this.isValidDividendIndex(dividendIndex), ErrorCode.InvalidDividend, 'Invalid dividend index');
     const dividend = await this.getDividendData({ dividendIndex });
     assert.assert(
       !dividend.claimedAmount.isGreaterThan(0),
+      ErrorCode.InvalidData,
       'Dividend claimed amount greater than 0, dividend reclaimed',
     );
     assert.isPastDate(dividend.maturity, 'Dividend maturity in future');
@@ -494,17 +583,21 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
   ) => {
     excluded.forEach(address => assert.isNonZeroETHAddressHex('Excluded address', address));
     assert.areThereDuplicatedStrings('Excluded addresses', excluded);
-    assert.assert(excluded.length <= EXCLUDED_ADDRESS_LIMIT, 'Too many addresses excluded');
-    assert.assert(expiry > maturity, 'Expiry before maturity');
+    assert.assert(
+      excluded.length <= EXCLUDED_ADDRESS_LIMIT,
+      ErrorCode.InvalidLenghtLimit,
+      'Too many addresses excluded',
+    );
+    assert.assert(expiry > maturity, ErrorCode.TooLate, 'Expiry before maturity');
     assert.isFutureDate(expiry, 'Expiry in past');
     assert.isBigNumberGreaterThanZero(amount, 'No dividend sent');
-    assert.assert(name.length > 0, 'The name can not be empty');
+    assert.assert(name.length > 0, ErrorCode.InvalidData, 'The name can not be empty');
 
     const stContract = await this.securityTokenContract();
 
     if (checkpointId) {
       const currentCheckpointId = await stContract.currentCheckpointId.callAsync();
-      assert.assert(checkpointId <= currentCheckpointId.toNumber(), 'Invalid checkpoint');
+      assert.assert(checkpointId <= currentCheckpointId.toNumber(), ErrorCode.InvalidCheckpoint, 'Invalid checkpoint');
     }
 
     const callerAddress = await this.getCallerAddress(txData);
@@ -515,15 +608,18 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
       const erc20TokenAllowance = await erc20Detailed.allowance.callAsync(callerAddress, await this.address());
       assert.assert(
         erc20TokenAllowance.isGreaterThanOrEqualTo(amount),
+        ErrorCode.InvalidData,
         'Your allowance is less than dividend amount',
       );
       assert.assert(
         erc20TokenBalance.isGreaterThanOrEqualTo(amount),
+        ErrorCode.InvalidData,
         'Your balance is less than dividend amount',
       );
     } else {
       assert.assert(
         (await this.web3Wrapper.getBalanceInWeiAsync(callerAddress)).isGreaterThanOrEqualTo(amount.valueOf()),
+        ErrorCode.PreconditionRequired,
         'Caller Address ETH Balance does not meet amount needed to create dividend',
       );
     }
@@ -541,7 +637,11 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
       currentSupply = await stContract.totalSupply.callAsync();
     }
 
-    assert.assert(!currentSupply.isZero(), 'Invalid supply, current supply must be greater than 0');
+    assert.assert(
+      !currentSupply.isZero(),
+      ErrorCode.InvalidData,
+      'Invalid supply, current supply must be greater than 0',
+    );
 
     // that hardcoded 0 is necessary for the sum function not
     // to return NaN if the excluded addresses array is empty
@@ -550,6 +650,7 @@ export default abstract class DividendCheckpointWrapper extends ModuleWrapper {
 
     assert.assert(
       currentSupply.isGreaterThan(totalExcludedSupply),
+      ErrorCode.InvalidData,
       'Invalid supply, current supply must be greater than excluded supply',
     );
   };

src/types.ts

@@ -337,15 +337,22 @@ export const PERCENTAGE_DECIMALS = new BigNumber(16);
 export const FULL_DECIMALS = new BigNumber(18);
 
 export enum ErrorCode {
-  UserDeniedAccess = 'UserDeniedAccess',
+  Unauthorized = 'Unauthorized',
   InvalidAddress = 'InvalidAddress',
   InsufficientBalance = 'InsufficientBalance',
   InvalidSubscriptionToken = 'InvalidSubscriptionToken',
   DuplicatedStrings = 'DuplicatedStrings',
-  TooFar = 'TooFar',
+  TooLate = 'TooLate',
   TooEarly = 'TooEarly',
   InvalidData = 'InvalidData',
   MismatchedArrayLength = 'MismatchedArrayLength',
   InvalidVersion = 'InvalidVersion',
   InvalidPartition = 'InvalidPartition',
+  ContractPaused = 'ContractPaused',
+  PreconditionRequired = 'PreconditionRequired',
+  AlreadyClaimed = 'AlreadyClaimed',
+  AddressExcluded = 'AddressExcluded',
+  InvalidDividend = 'InvalidDividend',
+  InvalidCheckpoint = 'InvalidCheckpoint',
+  InvalidLenghtLimit = 'InvalidLenghtLimit',
 }