fix: review comments addressed

Author: Victor Wiebe

src/entities/SecurityToken/Issuance/Issuance.ts

@@ -52,7 +52,7 @@ export class Issuance extends SubModule {
 
   /**
    * Retrieve whether the issuance of tokens is allowed or not
-   * Can be modified with `freeze`
+   * Can be permanently frozen with `freeze`
    */
   public allowed = async (): Promise<Boolean> => {
     const {

src/entities/SecurityToken/SecurityToken.ts

@@ -27,12 +27,12 @@ export interface Params {
   name: string;
   address: string;
   owner: string;
-  tokenDetails?: string;
-  version?: BigNumber[];
-  granularity?: number;
-  totalSupply?: BigNumber;
-  currentCheckpoint?: number;
-  treasuryWallet?: string;
+  tokenDetails: string;
+  version: BigNumber[];
+  granularity: number;
+  totalSupply: BigNumber;
+  currentCheckpoint: number;
+  treasuryWallet: string;
 }
 
 export const unserialize = (serialized: string) => {

src/entities/SecurityToken/Transfers/Transfers.ts

@@ -17,9 +17,9 @@ export class Transfers extends SubModule {
 
   /**
    * Retrieve whether the transfer of tokens is frozen or not
-   * Can be modified with `freeze`
+   * Can be modified with `freeze` and `unfreeze`
    */
-  public frozen = async (): Promise<Boolean> => {
+  public frozen = async (): Promise<boolean> => {
     const {
       context: { contractWrappers },
       securityToken,

src/procedures/CreateCheckpoint.ts

@@ -18,7 +18,7 @@ export const createRefreshSecurityTokenFactoryResolver = (
   return factories.securityTokenFactory.refresh(securityTokenId);
 };
 
-export class CreateCheckpoint extends Procedure<CreateCheckpointProcedureArgs, Checkpoint | void> {
+export class CreateCheckpoint extends Procedure<CreateCheckpointProcedureArgs, Checkpoint> {
   public type = ProcedureType.CreateCheckpoint;
 
   public async prepareTransactions() {

src/procedures/CreateSecurityToken.ts

@@ -68,7 +68,9 @@ export class CreateSecurityToken extends Procedure<
       });
     }
 
-    const [usdFee, polyFee] = await securityTokenRegistry.getFees({ feeType: FeeType.StLaunchFee });
+    const [usdFee, polyFee] = await securityTokenRegistry.getFees({
+      feeType: FeeType.StLaunchFee,
+    });
 
     await this.addProcedure(ApproveErc20)({
       amount: polyFee,
@@ -86,32 +88,7 @@ export class CreateSecurityToken extends Procedure<
       },
       resolvers: [
         async receipt => {
-          const { logs } = receipt;
-
-          const [event] = findEvents({
-            eventName: SecurityTokenRegistryEvents.NewSecurityToken,
-            logs,
-          });
-
-          if (event) {
-            const { args: eventArgs } = event;
-
-            const { _ticker, _name, _owner, _securityTokenAddress } = eventArgs;
-
-            return factories.securityTokenFactory.create(
-              SecurityToken.generateId({ symbol: _ticker }),
-              {
-                name: _name,
-                owner: _owner,
-                address: _securityTokenAddress,
-              }
-            );
-          }
-          throw new PolymathError({
-            code: ErrorCode.UnexpectedEventLogs,
-            message:
-              "The Security Token was successfully created but the corresponding event wasn't fired. Please report this issue to the Polymath team.",
-          });
+          return factories.securityTokenFactory.fetch(SecurityToken.generateId({ symbol }));
         },
       ],
     })({

src/procedures/IssueTokens.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from '@polymathnetwork/contract-wrappers';
+import { BigNumber, TransactionParams } from '@polymathnetwork/contract-wrappers';
 import { difference } from 'lodash';
 import { Procedure } from './Procedure';
 import {
@@ -20,7 +20,7 @@ export const createRefreshSecurityTokenFactoryResolver = (
   return factories.securityTokenFactory.refresh(securityTokenId);
 };
 
-export class IssueTokens extends Procedure<IssueTokensProcedureArgs, Shareholder[] | void> {
+export class IssueTokens extends Procedure<IssueTokensProcedureArgs, Shareholder[]> {
   public type = ProcedureType.IssueTokens;
 
   public async prepareTransactions() {
@@ -122,7 +122,10 @@ export class IssueTokens extends Procedure<IssueTokensProcedureArgs, Shareholder
     }
     const { uid: securityTokenId } = securityTokenEntity;
 
-    const [newShareholders] = await this.addTransaction(securityToken.issueMulti, {
+    const [newShareholders] = await this.addTransaction<
+      TransactionParams.SecurityToken.IssueMulti,
+      [Shareholder[], void]
+    >(securityToken.issueMulti, {
       tag: PolyTransactionTag.IssueMulti,
       resolvers: [
         async () => {

src/procedures/__tests__/CreateSecurityToken.ts

@@ -10,7 +10,7 @@ import { CreateSecurityToken } from '../../procedures/CreateSecurityToken';
 import { Procedure } from '../../procedures/Procedure';
 import { Wallet } from '../../Wallet';
 import { PolymathError } from '../../PolymathError';
-import { ErrorCode, PolyTransactionTag, ProcedureType } from '../../types';
+import { ErrorCode, PolyTransactionTag, ProcedureType, StoType } from '../../types';
 import { ApproveErc20 } from '../ApproveErc20';
 import * as securityTokenFactoryModule from '../../entities/factories/SecurityTokenFactory';
 import * as utilsModule from '../../utils';
@@ -104,64 +104,26 @@ describe('CreateSecurityToken', () => {
       );
     });
 
-    test('should throw if corresponding create security token event is not fired', async () => {
-      ImportMock.mockFunction(utilsModule, 'findEvents', []);
-
-      // Real call
-      const resolver = await target.prepareTransactions();
-
-      await expect(resolver.run({} as TransactionReceiptWithDecodedLogs)).rejects.toThrow(
-        new PolymathError({
-          code: ErrorCode.UnexpectedEventLogs,
-          message:
-            "The Security Token was successfully created but the corresponding event wasn't fired. Please report this issue to the Polymath team.",
-        })
-      );
-    });
-
     test('should return the newly created security token', async () => {
-      const creationObject = {
+      const fakeSecurityToken = {
         name: () => params.name,
         owner: () => params.owner,
         address: () => params.address,
       };
 
-      const createStub = securityTokenFactoryMock.mock('create', creationObject);
-      const findEventsStub = ImportMock.mockFunction(utilsModule, 'findEvents', [
-        {
-          args: {
-            _ticker: params.symbol,
-            _name: params.name,
-            _owner: params.owner,
-            _securityTokenAddress: params.address,
-          },
-        },
-      ]);
+      const fetchStub = securityTokenFactoryMock.mock('fetch', Promise.resolve(fakeSecurityToken));
 
       // Real call
       const resolver = await target.prepareTransactions();
       const receipt = {} as TransactionReceiptWithDecodedLogs;
       await resolver.run(receipt);
 
       // Verifications
-      expect(resolver.result).toEqual(creationObject);
+      expect(resolver.result).toEqual(fakeSecurityToken);
       expect(
-        createStub
-          .getCall(0)
-          .calledWithExactly(SecurityToken.generateId({ symbol: params.symbol }), {
-            name: params.name,
-            owner: params.owner,
-            address: params.address,
-          })
-      ).toEqual(true);
-      expect(createStub.callCount).toBe(1);
-      // Verifications for findEvents
-      expect(
-        findEventsStub.getCall(0).calledWithMatch({
-          eventName: SecurityTokenRegistryEvents.NewSecurityToken,
-        })
+        fetchStub.getCall(0).calledWithExactly(SecurityToken.generateId({ symbol: params.symbol }))
       ).toEqual(true);
-      expect(findEventsStub.callCount).toBe(1);
+      expect(fetchStub.callCount).toBe(1);
     });
 
     test('should throw error if token has been reserved by other user', async () => {