feat: 🎸 error handle implemented with PolymathError class

add PolymatError class to handle erros and retrieve ErrorCode type

Author: shuffledex

src/PolymathError.ts

@@ -0,0 +1,11 @@
+import { ErrorCode } from './types';
+
+export class PolymathError extends Error {
+  public code: ErrorCode;
+
+  // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+  constructor({ message, code }: { message?: string; code: ErrorCode }) {
+    super(message || `Unknown error, code: ${code}`);
+    this.code = code;
+  }
+}

src/types.ts

@@ -335,3 +335,17 @@ export type DividendCheckpointBaseContract = ERC20DividendCheckpointContract | E
 
 export const PERCENTAGE_DECIMALS = new BigNumber(16);
 export const FULL_DECIMALS = new BigNumber(18);
+
+export enum ErrorCode {
+  UserDeniedAccess = 'UserDeniedAccess',
+  InvalidAddress = 'InvalidAddress',
+  InsufficientBalance = 'InsufficientBalance',
+  InvalidSubscriptionToken = 'InvalidSubscriptionToken',
+  DuplicatedStrings = 'DuplicatedStrings',
+  TooFar = 'TooFar',
+  TooEarly = 'TooEarly',
+  InvalidData = 'InvalidData',
+  MismatchedArrayLength = 'MismatchedArrayLength',
+  InvalidVersion = 'InvalidVersion',
+  InvalidPartition = 'InvalidPartition',
+}

src/utils/assert.ts

@@ -1,6 +1,7 @@
 import { assert as sharedAssert } from '@0x/assert';
 import { BigNumber } from '@polymathnetwork/abi-wrappers';
-import {Partition} from '../types';
+import { Partition, ErrorCode } from '../types';
+import { PolymathError } from '../PolymathError';
 
 const ZERO = '0x0000000000000000000000000000000000000000';
 const MAX_64_BYTES_DATE = new Date(18446744073709);
@@ -9,61 +10,75 @@ const BIG_NUMBER_ZERO = new BigNumber(0);
 
 const assert = {
   ...sharedAssert,
+  assert(condition: boolean, code: ErrorCode, message?: string): void {
+    if (!condition) {
+      throw new PolymathError({ message, code });
+    }
+  },
   isValidSubscriptionToken(variableName: string, subscriptionToken: string): void {
     const uuidRegex = new RegExp('^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$');
     const isValid = uuidRegex.test(subscriptionToken);
-    sharedAssert.assert(isValid, `Expected ${variableName} to be a valid subscription token`);
+    this.assert(
+      isValid,
+      ErrorCode.InvalidSubscriptionToken,
+      `Expected ${variableName} to be a valid subscription token`,
+    );
   },
   isNonZeroETHAddressHex(variableName: string, address: string): void {
     sharedAssert.isETHAddressHex(variableName, address);
-    sharedAssert.assert(address !== ZERO, `'${variableName}' is not expected to be 0x0`);
+    this.assert(address !== ZERO, ErrorCode.InvalidAddress, `'${variableName}' is not expected to be 0x0`);
   },
   areThereDuplicatedStrings(variableName: string, addresses: string[]): void {
     const result = addresses.length === new Set(addresses).size;
-    sharedAssert.assert(result, `There are duplicates in ${variableName} array.`);
+    this.assert(result, ErrorCode.DuplicatedStrings, `There are duplicates in ${variableName} array.`);
   },
   isLessThanMax64BytesDate(variableName: string, value: Date): void {
-    sharedAssert.assert(value <= MAX_64_BYTES_DATE, `${variableName} date is too far in the future`);
+    this.assert(value <= MAX_64_BYTES_DATE, ErrorCode.TooFar, `${variableName} date is too far in the future`);
   },
   isPercentage(variableName: string, value: BigNumber): void {
-    sharedAssert.assert(
+    this.assert(
       value.isLessThanOrEqualTo(MAX_PERCENTAGE),
+      ErrorCode.InvalidData,
       `${variableName} is not expected to be greater than 100%`,
     );
   },
   isFutureDate(value: Date, message: string): void {
-    sharedAssert.assert(value >= new Date(), message);
+    this.assert(value >= new Date(), ErrorCode.TooEarly, message);
   },
   isPastDate(value: Date, message: string): void {
-    sharedAssert.assert(value <= new Date(), message);
+    this.assert(value <= new Date(), ErrorCode.TooFar, message);
   },
   isNotDateZero(value: Date, message: string): void {
-    sharedAssert.assert(value !== new Date(0), message);
+    this.assert(value !== new Date(0), ErrorCode.InvalidData, message);
   },
   isBigNumberZero(value: BigNumber, message: string): void {
-    sharedAssert.assert(value.isEqualTo(BIG_NUMBER_ZERO), message);
+    this.assert(value.isEqualTo(BIG_NUMBER_ZERO), ErrorCode.InvalidData, message);
   },
   isBigNumberGreaterThanZero(value: BigNumber, message: string): void {
-    sharedAssert.assert(value >= BIG_NUMBER_ZERO, message);
-  },  
-  areValidArrayLengths(value: any[][], message: string) { // eslint-disable-line
-    sharedAssert.assert(
-      value.every((x: any[]) => { // eslint-disable-line
+    this.assert(value >= BIG_NUMBER_ZERO, ErrorCode.InvalidData, message);
+  },
+  areValidArrayLengths(value: any[][], message: string) {
+    // eslint-disable-line
+    this.assert(
+      value.every((x: any[]) => {
+        // eslint-disable-line
         return x.length === value[0].length;
       }),
+      ErrorCode.MismatchedArrayLength,
       message,
     );
   },
   // eslint-enable no-any
   isValidVersion(version: string) {
-    sharedAssert.assert(
+    this.assert(
       /^(\d+\.)(\d+\.)(\d+)$/.test(version),
+      ErrorCode.InvalidVersion,
       'Invalid package version. Right format: major.minor.patch',
     );
   },
   isValidPartition(partition: Partition) {
-    sharedAssert.assert(partition === Partition.Unlocked, 'Invalid Partition');
-  }
+    this.assert(partition === Partition.Unlocked, ErrorCode.InvalidPartition, 'Invalid Partition');
+  },
 };
 
 export default assert;