fix: 🐛 generateNewSecurityToken in STR missing assertions

Author: Victor Wiebe

src/contract_wrappers/registries/__tests__/security_token_registry_wrapper.test.ts

@@ -499,9 +499,45 @@ describe('SecurityTokenRegistryWrapper', () => {
 
   describe('GenerateNewSecurityToken', () => {
     test('should call generateNewSecurityToken with NewSecurityTokenParams', async () => {
+      const ticker = 'TICK';
+      const expectedOwnerResult = '0x0123456789012345678901234567890123456789';
+      // Mocked method
+      const mockedOwnerMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.owner).thenReturn(instance(mockedOwnerMethod));
+      // Stub the request
+      when(mockedOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
+
+      const expectedTickerDetailsResult = [
+        '0x0123456789012345678901234567890123456789',
+        new BigNumber(1735689600),
+        new BigNumber(1735689605),
+        ticker,
+        false,
+      ];
+
+      const mockedGetTickerDetailsMethod = mock(MockedCallMethod);
+      when(mockedContract.getTickerDetails).thenReturn(instance(mockedGetTickerDetailsMethod));
+      when(mockedGetTickerDetailsMethod.callAsync(ticker)).thenResolve(expectedTickerDetailsResult);
+
+      when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
+
+      // Get Security token launch fee
+      const expectedLaunchFeeResult = valueToWei(new BigNumber(10), FULL_DECIMALS);
+      const mockedLaunchFeeMethod = mock(MockedSendMethod);
+      when(mockedContract.getSecurityTokenLaunchFee).thenReturn(instance(mockedLaunchFeeMethod));
+      when(mockedLaunchFeeMethod.callAsync()).thenResolve(expectedLaunchFeeResult);
+
+      // Get ERC20 Allowance
+      const erc20Allowance = valueToWei(new BigNumber(100), FULL_DECIMALS);
+      when(mockedContractFactory.getPolyTokenContract()).thenResolve(instance(mockedPolyTokenContract));
+      const mockedPolyTokenBalanceOfMethod = mock(MockedCallMethod);
+      when(mockedPolyTokenBalanceOfMethod.callAsync(expectedOwnerResult)).thenResolve(erc20Allowance);
+      when(mockedPolyTokenContract.balanceOf).thenReturn(instance(mockedPolyTokenBalanceOfMethod));
+      
       const mockedParams = {
         name: "TOKEN TEST",
-        ticker: "TTEST",
+        ticker,
         tokenDetails: "",
         divisible: true,
         treasuryWallet: "0x0023456789002345678900234567890023456789",
@@ -548,6 +584,16 @@ describe('SecurityTokenRegistryWrapper', () => {
           mockedParams.safetyFactor,
         ),
       ).once();
+      verify(mockedContract.owner).once();
+      verify(mockedOwnerMethod.callAsync()).once();
+      verify(mockedWrapper.getAvailableAddressesAsync()).twice();
+      verify(mockedContract.getTickerDetails).once();
+      verify(mockedGetTickerDetailsMethod.callAsync(ticker)).once();
+      verify(mockedContract.getSecurityTokenLaunchFee).once();
+      verify(mockedLaunchFeeMethod.callAsync()).once();
+      verify(mockedContractFactory.getPolyTokenContract()).once();
+      verify(mockedPolyTokenBalanceOfMethod.callAsync(expectedOwnerResult)).once();
+      verify(mockedPolyTokenContract.balanceOf).once();
     });
   });
 

src/contract_wrappers/registries/security_token_registry_wrapper.ts

@@ -680,6 +680,27 @@ export default class SecurityTokenRegistryWrapper extends ContractWrapper {
   };
 
   public generateNewSecurityToken = async (params: NewSecurityTokenParams) => {
+    assert.assert(params.ticker.length > 0, 'Ticker is empty');
+    assert.assert(params.name.length > 0, 'Name is empty');
+    await this.checkWhenNotPausedOrOwner();
+    const tickerDetails = await this.getTickerDetails({
+      tokenName: params.ticker,
+    });
+    assert.assert(!tickerDetails.status, 'Ticker already deployed');
+    const address = (await this.web3Wrapper.getAvailableAddressesAsync())[0];
+    assert.assert(functionsUtils.checksumAddressComparision(address, tickerDetails.owner), 'Not authorised');
+    assert.assert(tickerDetails.expiryDate.getTime() >= Date.now(), 'Ticker gets expired');
+
+    // Check PolyToken allowance
+    const securityTokenLaunchFee = await this.getSecurityTokenLaunchFee();
+    if (securityTokenLaunchFee.isGreaterThan(BIG_NUMBER_ZERO)) {
+      const polyBalance = weiToValue(
+          await (await this.polyTokenContract()).balanceOf.callAsync(address),
+          FULL_DECIMALS,
+      );
+      assert.assert(polyBalance.isGreaterThanOrEqualTo(securityTokenLaunchFee), 'Insufficient Poly token allowance');
+    }
+
     const version = params.protocolVersion;
     let protocolVersion = new BigNumber(0);
     if (version !== '0') {