feat: add ticker availability check

Author: remon-nashid

src/LowLevel/SecurityTokenRegistry.ts

@@ -9,6 +9,9 @@ import {
   RegisterTickerArgs,
   GenerateSecurityTokenArgs,
   GetSecurityTokenArgs,
+  GetTickerDetailsArgs,
+  IsTickerAvailableArgs,
+  TickerDetails,
 } from './types';
 import { fromWei } from './utils';
 
@@ -19,6 +22,9 @@ interface SecurityTokenRegistryContract extends GenericContract {
       ticker: string,
       tokenName: string
     ): TransactionObject<void>;
+    getTickerDetails(
+      ticker: string
+    ): TransactionObject<{ [key: string]: string }>;
     getTickerRegistrationFee(): TransactionObject<string>;
     getSecurityTokenLaunchFee(): TransactionObject<string>;
     getSecurityTokenAddress(ticker: string): TransactionObject<string>;
@@ -49,6 +55,68 @@ export class SecurityTokenRegistry extends Contract<
         .send({ from: this.context.account });
   };
 
+  public getTickerDetails = async ({ ticker }: GetTickerDetailsArgs) => {
+    const keysMap: { [key: string]: string } = {
+      '0': 'owner',
+      '1': 'registrationDate',
+      '2': 'expiryDate',
+      '3': 'name',
+      '4': 'status',
+    };
+
+    const details = await this.contract.methods
+      .getTickerDetails(ticker)
+      .call({ from: this.context.account });
+
+    // Convert the object returned by SecurityTokenRegistry.getTickerDetails to a TickerDetails object.
+    try {
+      const initialValue = <TickerDetails>{
+        owner: '0x0000000000000000000000000000000000000000',
+        registrationDate: 0,
+        expiryDate: 0,
+        name: '',
+        status: false,
+      };
+      const labeledDetails: TickerDetails = Object.keys(details).reduce(
+        (acc, cur: string) => {
+          let val: string | number = details[cur];
+          // Parse unix timestamps.
+          if (cur === '1' || cur === '2') {
+            val = parseInt(val);
+          }
+          const newKey: string = keysMap[cur];
+          acc[newKey] = val;
+          return acc;
+        },
+        initialValue
+      );
+
+      return labeledDetails;
+    } catch (error) {
+      throw new Error('Unexpected ticker details data.');
+    }
+  };
+
+  /**
+   * While lacking a public, smart contract function to check for ticker availability, this function attempts to
+   * immitate the internal function SecurityTokenRegistry._tickerAvailable()
+   * @see https://github.com/PolymathNetwork/polymath-core/blob/aa635df01588f733ce95bc13fe319c7d3c858a24/contracts/SecurityTokenRegistry.sol#L318
+   */
+  public isTickerAvailable = async ({
+    ticker,
+  }: IsTickerAvailableArgs): Promise<boolean> => {
+    const details = await this.getTickerDetails({ ticker });
+
+    if (details.owner !== '0x0000000000000000000000000000000000000000') {
+      if (Date.now() > details.expiryDate * 1000 && !details.status) {
+        return true;
+      }
+      return false;
+    }
+
+    return true;
+  };
+
   public generateSecurityToken = async ({
     tokenName,
     ticker,

src/LowLevel/types.ts

@@ -229,6 +229,23 @@ export interface GetSecurityTokenArgs {
   ticker: string;
 }
 
+export interface GetTickerDetailsArgs {
+  ticker: string;
+}
+
+export interface IsTickerAvailableArgs {
+  ticker: string;
+}
+
+export interface TickerDetails {
+  [key: string]: any;
+  owner: string;
+  registrationDate: number;
+  expiryDate: number;
+  name: string;
+  status: boolean;
+}
+
 export enum NetworkIds {
   Local = 15,
   LocalVm = 16,

src/procedures/ReserveSecurityToken.ts

@@ -30,10 +30,18 @@ export class ReserveSecurityToken extends Procedure<
       });
     }
 
-    // TODO @RafaelVidaurre: See if ticker is not already registered
+    const isAvailable = await securityTokenRegistry.isTickerAvailable({
+      ticker: symbol,
+    });
+    // @TODO remon-nashid perhaps we should display an error message rather than throwing?
+    if (!isAvailable) {
+      throw new PolymathError({
+        message: `Ticker ${symbol} has already been registered`,
+        code: ErrorCodes.ProcedureValidationError,
+      });
+    }
 
     const fee = await securityTokenRegistry.getTickerRegistrationFee();
-
     await this.addTransaction(Approve)({
       amount: fee,
       spender: securityTokenRegistry.address,