feat: add procedure to launch a USD Tiered STO

also renamed some types and procedure params to make them more understandable

Author: monitz87

src/Polymath.ts

@@ -22,9 +22,10 @@ import {
   ErrorCode,
   ModuleOperation,
   DividendModuleType,
-  FundraiseType,
+  Currency,
+  CappedStoCurrency,
   StoModuleType,
-  CappedStoFundraiseType,
+  StoTier,
 } from './types';
 import {
   Dividend as DividendEntity,
@@ -58,6 +59,7 @@ import {
   PauseSto,
   SetController,
   LaunchCappedSto,
+  LaunchUsdTieredSto,
 } from './procedures';
 import { Entity } from './entities/Entity';
 import { DividendsModule } from './entities/DividendsModule';
@@ -204,22 +206,22 @@ export class Polymath {
    * Launch a Capped STO
    *
    * @param securityTokenId token uuid
-   * @param startTime date when the STO should start
-   * @param endTime date when the STO should end
-   * @param cap amount to be raised
+   * @param startDate date when the STO should start
+   * @param endDate date when the STO should end
+   * @param tokensOnSale amount of tokens to be sold
    * @param rate amount of tokens an investor can purchase per unit of currency spent
-   * @param fundRaiseType currency in which the funds will be raised (ETH, POLY)
-   * @param fundsReceiver wallet address that will receive the funds that are being raised
+   * @param currency currency in which the funds will be raised (ETH or POLY)
+   * @param storageWallet wallet address that will receive the funds that are being raised
    *
    */
   public launchCappedSto = async (args: {
     securityTokenId: string;
-    startTime: Date;
-    endTime: Date;
-    cap: BigNumber;
+    startDate: Date;
+    endDate: Date;
+    tokensOnSale: BigNumber;
     rate: BigNumber;
-    fundRaiseType: CappedStoFundraiseType;
-    fundsReceiver: string;
+    currency: CappedStoCurrency;
+    storageWallet: string;
   }) => {
     const { securityTokenId, ...rest } = args;
     const { symbol } = this.SecurityToken.unserialize(securityTokenId);
@@ -233,6 +235,49 @@ export class Polymath {
     return await procedure.prepare();
   };
 
+  /**
+   * Launch a USD Tiered STO
+   *
+   * @param securityTokenId token uuid
+   * @param startDate date when the STO should start
+   * @param endDate date when the STO should end
+   * @param tiers tier information
+   * @param tiers[].tokensOnSale amount of tokens to be sold on that tier
+   * @param tiers[].price price of each token on that tier in USD
+   * @param tiers[].tokensWithDiscount amount of tokens to be sold on that tier at a discount if paid in POLY (must be less than tokensOnSale)
+   * @param tiers[].discountedPrice price of discounted tokens on that tier
+   * @param nonAccreditedInvestmentLimit maximum investment for non-accredited investors
+   * @param minimumInvestment minimum investment amount
+   * @param currencies array of currencies in which the funds will be raised (ETH, POLY, StableCoin)
+   * @param storageWallet wallet address that will receive the funds that are being raised
+   * @param treasuryWallet wallet address that will receive unsold tokens when the end date is reached
+   * @param usdTokenAddresses array of USD stable coins that the offering supports
+   *
+   */
+  public launchUsdTieredSto = async (args: {
+    securityTokenId: string;
+    startDate: Date;
+    endDate: Date;
+    tiers: StoTier[];
+    nonAccreditedInvestmentLimit: BigNumber;
+    minimumInvestment: BigNumber;
+    currencies: Currency[];
+    storageWallet: string;
+    treasuryWallet: string;
+    usdTokenAddresses: string[];
+  }) => {
+    const { securityTokenId, ...rest } = args;
+    const { symbol } = this.SecurityToken.unserialize(securityTokenId);
+    const procedure = new LaunchUsdTieredSto(
+      {
+        symbol,
+        ...rest,
+      },
+      this.context
+    );
+    return await procedure.prepare();
+  };
+
   /**
    * Enable dividend modules (ERC20, ETH or both)
    *
@@ -931,7 +976,7 @@ export class Polymath {
 
           stoModules.push(
             new this.CappedStoModule({
-              fundraiseTypes: isRaisedInPoly ? [FundraiseType.POLY] : [FundraiseType.ETH],
+              fundraiseTypes: isRaisedInPoly ? [Currency.POLY] : [Currency.ETH],
               raisedAmount: fundsRaised,
               soldTokensAmount: totalTokensSold,
               investorAmount: investorCount,
@@ -996,15 +1041,15 @@ export class Polymath {
           const fundraiseTypes = [];
 
           if (isRaisedInETH) {
-            fundraiseTypes.push(FundraiseType.ETH);
+            fundraiseTypes.push(Currency.ETH);
           }
 
           if (isRaisedInPOLY) {
-            fundraiseTypes.push(FundraiseType.POLY);
+            fundraiseTypes.push(Currency.POLY);
           }
 
           if (isRaisedInSC) {
-            fundraiseTypes.push(FundraiseType.StableCoin);
+            fundraiseTypes.push(Currency.StableCoin);
           }
 
           stoModules.push(

src/entities/StoModule.ts

@@ -2,7 +2,7 @@ import { BigNumber } from '@polymathnetwork/contract-wrappers';
 import { Polymath } from '../Polymath';
 import { Entity } from './Entity';
 import { unserialize } from '../utils';
-import { StoModuleType, isStoModuleType, FundraiseType } from '../types';
+import { StoModuleType, isStoModuleType, Currency } from '../types';
 import { Investment } from './Investment';
 
 export interface UniqueIdentifiers {
@@ -23,7 +23,7 @@ export interface Params extends UniqueIdentifiers {
   securityTokenSymbol: string;
   startTime: Date;
   endTime: Date;
-  fundraiseTypes: FundraiseType[];
+  fundraiseTypes: Currency[];
   raisedAmount: BigNumber;
   soldTokensAmount: BigNumber;
   investorAmount: number;
@@ -55,7 +55,7 @@ export abstract class StoModule extends Entity {
 
   public investments: Investment[];
 
-  public fundraiseTypes: FundraiseType[];
+  public fundraiseTypes: Currency[];
 
   public paused: boolean;
 

src/procedures/Approve.ts

@@ -76,7 +76,7 @@ export class Approve extends Procedure<ApproveProcedureArgs> {
     }
 
     await this.addTransaction(token.approve, {
-      tag: PolyTransactionTag.Approve,
+      tag: PolyTransactionTag.ApprovePoly,
     })({ spender, value: amount });
   }
 }

src/procedures/LaunchCappedSto.ts

@@ -27,7 +27,7 @@ export class LaunchCappedSto extends Procedure<LaunchCappedStoProcedureArgs> {
   public type = ProcedureType.LaunchCappedSto;
 
   public async prepareTransactions() {
-    const { symbol, ...data } = this.args;
+    const { symbol, startDate, endDate, tokensOnSale, rate, currency, storageWallet } = this.args;
     const { contractWrappers } = this.context;
 
     let securityToken;
@@ -55,7 +55,7 @@ export class LaunchCappedSto extends Procedure<LaunchCappedStoProcedureArgs> {
     const cost = await moduleFactory.setupCostInPoly();
 
     await this.addTransaction(contractWrappers.polyToken.transfer, {
-      tag: PolyTransactionTag.Transfer,
+      tag: PolyTransactionTag.TransferPoly,
     })({
       to: tokenAddress,
       value: cost,
@@ -66,7 +66,14 @@ export class LaunchCappedSto extends Procedure<LaunchCappedStoProcedureArgs> {
     })({
       moduleName,
       address: factoryAddress,
-      data,
+      data: {
+        startTime: startDate,
+        endTime: endDate,
+        cap: tokensOnSale,
+        rate,
+        fundRaiseType: currency,
+        fundsReceiver: storageWallet,
+      },
       archived: false,
     });
   }

src/procedures/LaunchUsdTieredSto.ts

@@ -0,0 +1,122 @@
+import { ModuleName, BigNumber, FundRaiseType } from '@polymathnetwork/contract-wrappers';
+import { Procedure } from './Procedure';
+import {
+  ProcedureType,
+  PolyTransactionTag,
+  ErrorCode,
+  LaunchUsdTieredStoProcedureArgs,
+} from '../types';
+import { PolymathError } from '../PolymathError';
+
+interface AddUSDTieredSTOParams {
+  moduleName: ModuleName.UsdTieredSTO;
+  address: string;
+  data: {
+    startTime: Date;
+    endTime: Date;
+    ratePerTier: BigNumber[];
+    ratePerTierDiscountPoly: BigNumber[];
+    tokensPerTierTotal: BigNumber[];
+    tokensPerTierDiscountPoly: BigNumber[];
+    nonAccreditedLimitUSD: BigNumber;
+    minimumInvestmentUSD: BigNumber;
+    fundRaiseTypes: FundRaiseType[];
+    wallet: string;
+    treasuryWallet: string;
+    usdTokens: string[];
+  };
+  archived: boolean;
+  label?: string;
+}
+
+export class LaunchUsdTieredSto extends Procedure<LaunchUsdTieredStoProcedureArgs> {
+  public type = ProcedureType.LaunchUsdTieredSto;
+
+  public async prepareTransactions() {
+    const {
+      symbol,
+      startDate,
+      endDate,
+      tiers,
+      nonAccreditedInvestmentLimit,
+      minimumInvestment,
+      currencies,
+      storageWallet,
+      treasuryWallet,
+      usdTokenAddresses,
+    } = this.args;
+    const { contractWrappers } = this.context;
+
+    let securityToken;
+
+    try {
+      securityToken = await contractWrappers.tokenFactory.getSecurityTokenInstanceFromTicker(
+        symbol
+      );
+    } catch (err) {
+      throw new PolymathError({
+        code: ErrorCode.ProcedureValidationError,
+        message: `There is no Security Token with symbol ${symbol}`,
+      });
+    }
+
+    const tokenAddress = await securityToken.address();
+    const moduleName = ModuleName.UsdTieredSTO;
+
+    const factoryAddress = await contractWrappers.getModuleFactoryAddress({
+      tokenAddress,
+      moduleName,
+    });
+
+    const moduleFactory = await contractWrappers.moduleFactory.getModuleFactory(factoryAddress);
+    const cost = await moduleFactory.setupCostInPoly();
+
+    await this.addTransaction(contractWrappers.polyToken.transfer, {
+      tag: PolyTransactionTag.TransferPoly,
+    })({
+      to: tokenAddress,
+      value: cost,
+    });
+
+    const ratePerTier: BigNumber[] = [];
+    const ratePerTierDiscountPoly: BigNumber[] = [];
+    const tokensPerTierTotal: BigNumber[] = [];
+    const tokensPerTierDiscountPoly: BigNumber[] = [];
+
+    tiers.forEach(
+      ({
+        tokensOnSale,
+        price,
+        tokensWithDiscount = new BigNumber(0),
+        discountedPrice = new BigNumber(0),
+      }) => {
+        ratePerTier.push(price);
+        ratePerTierDiscountPoly.push(discountedPrice);
+        tokensPerTierTotal.push(tokensOnSale);
+        tokensPerTierDiscountPoly.push(tokensWithDiscount);
+      }
+    );
+
+    await this.addTransaction<AddUSDTieredSTOParams>(securityToken.addModuleWithLabel, {
+      tag: PolyTransactionTag.EnableCappedSto,
+    })({
+      moduleName,
+      address: factoryAddress,
+      data: {
+        startTime: startDate,
+        endTime: endDate,
+        ratePerTier,
+        ratePerTierDiscountPoly,
+        tokensPerTierTotal,
+        tokensPerTierDiscountPoly,
+        nonAccreditedLimitUSD: nonAccreditedInvestmentLimit,
+        minimumInvestmentUSD: minimumInvestment,
+        fundRaiseTypes: currencies,
+        wallet: storageWallet,
+        treasuryWallet,
+        usdTokens: usdTokenAddresses,
+      },
+      archived: false,
+    });
+  }
+}

src/procedures/index.ts

@@ -16,3 +16,4 @@ export { ControllerTransfer } from './ControllerTransfer';
 export { PauseSto } from './PauseSto';
 export { SetController } from './SetController';
 export { LaunchCappedSto } from './LaunchCappedSto';
+export { LaunchUsdTieredSto } from './LaunchUsdTieredSto';