feat: create procedure to allow/disallow beneficial investment

Author: monitz87

src/entities/Sto.ts

@@ -5,7 +5,7 @@ import { StoType, isStoType, Currency, ErrorCode, StoRole } from '../types';
 import { Investment } from './Investment';
 import { PolymathError } from '../PolymathError';
 import { Context } from '../Context';
-import { PauseSto, AssignStoRole, FinalizeSto } from '../procedures';
+import { PauseSto, AssignStoRole, FinalizeSto, ModifyBeneficialInvestments } from '../procedures';
 import { ModifyPreMinting } from '../procedures/ModifyPreMinting';
 
 export interface UniqueIdentifiers {
@@ -190,6 +190,34 @@ export abstract class Sto<P> extends Entity<P> {
     return procedure.prepare();
   };
 
+  /**
+   * Enables a party to invest in the STO on behalf of another party
+   */
+  public allowBeneficialInvestments = async () => {
+    const { address: stoAddress, stoType, securityTokenSymbol: symbol } = this;
+
+    const procedure = new ModifyBeneficialInvestments(
+      { stoAddress, stoType, symbol, allowBeneficialInvestments: true },
+      this.context
+    );
+
+    return procedure.prepare();
+  };
+
+  /**
+   * Disables the possibility for a party to invest in the STO on behalf of another party
+   */
+  public disallowBeneficialInvestments = async () => {
+    const { address: stoAddress, stoType, securityTokenSymbol: symbol } = this;
+
+    const procedure = new ModifyBeneficialInvestments(
+      { stoAddress, stoType, symbol, allowBeneficialInvestments: false },
+      this.context
+    );
+
+    return procedure.prepare();
+  };
+
   /**
    * Assigns a role on the STO to a delegate
    *

src/procedures/ModifyBeneficialInvestments.ts

@@ -0,0 +1,113 @@
+import { ModuleName } from '@polymathnetwork/contract-wrappers';
+import { Procedure } from './Procedure';
+import {
+  ProcedureType,
+  PolyTransactionTag,
+  ModifyBeneficialInvestmentsProcedureArgs,
+  ErrorCode,
+  StoType,
+} from '../types';
+import { PolymathError } from '../PolymathError';
+import { isValidAddress } from '../utils';
+import { SecurityToken, CappedSto, TieredSto } from '../entities';
+
+export class ModifyBeneficialInvestments extends Procedure<
+  ModifyBeneficialInvestmentsProcedureArgs
+> {
+  public type = ProcedureType.PauseSto;
+
+  public async prepareTransactions() {
+    const { stoAddress, stoType, symbol, allowBeneficialInvestments } = this.args;
+    const { contractWrappers, factories } = this.context;
+
+    /**
+     * Validation
+     */
+
+    if (!isValidAddress(stoAddress)) {
+      throw new PolymathError({
+        code: ErrorCode.InvalidAddress,
+        message: `Invalid STO address ${stoAddress}`,
+      });
+    }
+
+    let stoModule;
+
+    switch (stoType) {
+      case StoType.Capped: {
+        stoModule = await contractWrappers.moduleFactory.getModuleInstance({
+          name: ModuleName.CappedSTO,
+          address: stoAddress,
+        });
+
+        break;
+      }
+      case StoType.Tiered: {
+        stoModule = await contractWrappers.moduleFactory.getModuleInstance({
+          name: ModuleName.UsdTieredSTO,
+          address: stoAddress,
+        });
+
+        break;
+      }
+      default: {
+        throw new PolymathError({
+          code: ErrorCode.ProcedureValidationError,
+          message: `Invalid STO type ${stoType}`,
+        });
+      }
+    }
+
+    if (!stoModule) {
+      throw new PolymathError({
+        code: ErrorCode.ProcedureValidationError,
+        message: `STO ${stoAddress} is either archived or hasn't been launched`,
+      });
+    }
+
+    const beneficialInvesmentsAllowed = await stoModule.allowBeneficialInvestments();
+
+    if (beneficialInvesmentsAllowed === allowBeneficialInvestments) {
+      throw new PolymathError({
+        code: ErrorCode.ProcedureValidationError,
+        message: `Beneficial investments are already ${
+          beneficialInvesmentsAllowed ? '' : 'dis'
+        }allowed`,
+      });
+    }
+
+    /**
+     * Transactions
+     */
+
+    await this.addTransaction(stoModule.changeAllowBeneficialInvestments, {
+      tag: PolyTransactionTag.ChangeAllowBeneficialInvestments,
+      resolvers: [
+        async () => {
+          const securityTokenId = SecurityToken.generateId({ symbol });
+
+          switch (stoType) {
+            case StoType.Capped: {
+              return factories.cappedStoFactory.refresh(
+                CappedSto.generateId({
+                  securityTokenId,
+                  stoType: StoType.Capped,
+                  address: stoAddress,
+                })
+              );
+            }
+            case StoType.Tiered: {
+              return factories.tieredStoFactory.refresh(
+                TieredSto.generateId({
+                  securityTokenId,
+                  stoType: StoType.Tiered,
+                  address: stoAddress,
+                })
+              );
+            }
+          }
+        },
+      ],
+    })({ allowBeneficialInvestments });
+  }
+}

src/procedures/ModifyPreMinting.ts

@@ -79,6 +79,15 @@ export class ModifyPreMinting extends Procedure<ModifyPreMintingProcedureArgs> {
       });
     }
 
+    const preMintingAllowed = await stoModule.preMintAllowed();
+
+    if (preMintingAllowed === allowPreMinting) {
+      throw new PolymathError({
+        code: ErrorCode.ProcedureValidationError,
+        message: `Pre-minting is already ${preMintingAllowed ? '' : 'dis'}allowed`,
+      });
+    }
+
     /**
      * Transactions
      */

src/procedures/index.ts

@@ -25,3 +25,4 @@ export { ModifyShareholderData } from './ModifyShareholderData';
 export { RevokeKyc } from './RevokeKyc';
 export { MintTokens } from './MintTokens';
 export { FinalizeSto } from './FinalizeSto';
+export { ModifyBeneficialInvestments } from './ModifyBeneficialInvestments';

src/types/index.ts

@@ -147,6 +147,7 @@ export enum ProcedureType {
   RevokeKyc = 'RevokeKyc',
   MintTokens = 'MintTokens',
   ModifyPreMinting = 'ModifyPreMinting',
+  ModifyBeneficialInvestments = 'ModifyBeneificialInvestments',
 }
 
 export enum PolyTransactionTag {
@@ -182,6 +183,7 @@ export enum PolyTransactionTag {
   IssueMulti = 'IssueMulti',
   AllowPreMinting = 'AllowPreMinting',
   RevokePreMinting = 'RevokePreMinting',
+  ChangeAllowBeneficialInvestments = 'ChangeAllowBeneficialInvestments',
 }
 
 export type MaybeResolver<T> = PostTransactionResolver<T> | T;
@@ -306,6 +308,13 @@ export interface ModifyPreMintingProcedureArgs {
   allowPreMinting: boolean;
 }
 
+export interface ModifyBeneficialInvestmentsProcedureArgs {
+  symbol: string;
+  stoAddress: string;
+  stoType: StoType;
+  allowBeneficialInvestments: boolean;
+}
+
 export interface StoTier {
   /**
    * Amount of tokens to sell in this tier