feat: add changeSTVersionBounds and associated tests

Author: Victor Wiebe

src/contract_wrappers/modules/__tests__/module_factory_wrapper.test.ts

@@ -17,7 +17,7 @@ import {
 } from '../../../utils/convert';
 import ModuleFactoryWrapper from '../module_factory_wrapper';
 import ContractWrapper from '../../contract_wrapper';
-import { FULL_DECIMALS, ModuleType } from '../../../types';
+import {BoundType, FULL_DECIMALS, ModuleType} from '../../../types';
 
 describe('ModuleFactoryWrapper', () => {
   let target: ModuleFactoryWrapper;
@@ -486,11 +486,11 @@ describe('ModuleFactoryWrapper', () => {
       when(mockedContract.changeTags).thenReturn(instance(mockedMethod));
       // Stub the request
       when(
-        mockedMethod.sendTransactionAsync(
-          objectContaining(stringArrayToBytes32Array(mockedParams.tags)),
-          mockedParams.txData,
-          mockedParams.safetyFactor,
-        ),
+          mockedMethod.sendTransactionAsync(
+              objectContaining(stringArrayToBytes32Array(mockedParams.tags)),
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
       ).thenResolve(expectedResult);
 
       // Owner Address expected
@@ -514,13 +514,82 @@ describe('ModuleFactoryWrapper', () => {
       verify(mockedOwnerMethod.callAsync()).once();
       verify(mockedContract.changeTags).once();
       verify(
-        mockedMethod.sendTransactionAsync(
-          objectContaining(stringArrayToBytes32Array(mockedParams.tags)),
-          mockedParams.txData,
-          mockedParams.safetyFactor,
-        ),
+          mockedMethod.sendTransactionAsync(
+              objectContaining(stringArrayToBytes32Array(mockedParams.tags)),
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
+      ).once();
+      verify(mockedWrapper.getAvailableAddressesAsync()).once();
+    });
+  });
+
+  describe('ChangeSTVersionBounds', () => {
+    test.todo('should fail as there is an invalid bound type used');
+    test.todo('should fail as tags array length is not 3');
+    test('should send the transaction to changeSTVersionBounds', async () => {
+      // Mocked parameters
+      const mockedParams = {
+        boundType: BoundType.LowerBound,
+        newVersion: [2, 3, 4],
+        txData: {},
+        safetyFactor: 10,
+      };
+      const expectedResult = getMockedPolyResponse();
+      // Mocked method
+      const mockedMethod = mock(MockedSendMethod);
+      // Stub the method
+      when(mockedContract.changeSTVersionBounds).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(
+          mockedMethod.sendTransactionAsync(
+              mockedParams.boundType,
+              mockedParams.newVersion,
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
+      ).thenResolve(expectedResult);
+
+      // Owner Address expected
+      const expectedOwnerResult = '0x5555555555555555555555555555555555555555';
+      // Mocked method
+      const mockedOwnerMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.owner).thenReturn(instance(mockedOwnerMethod));
+      // Stub the request
+      when(mockedOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
+      // Mock web3 wrapper owner
+      when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
+
+      // Address expected
+      const expectedLowerSTVersionBoundsResult = [new BigNumber(1), new BigNumber(2), new BigNumber(3)];
+      // Mocked method
+      const mockedLowerSTVersionBoundsMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.getLowerSTVersionBounds).thenReturn(instance(mockedLowerSTVersionBoundsMethod));
+      // Stub the request
+      when(mockedLowerSTVersionBoundsMethod.callAsync()).thenResolve(expectedLowerSTVersionBoundsResult);
+
+      // Real call
+      const result = await target.changeSTVersionBounds(mockedParams);
+
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.owner).once();
+      verify(mockedOwnerMethod.callAsync()).once();
+      verify(mockedContract.changeSTVersionBounds).once();
+      verify(
+          mockedMethod.sendTransactionAsync(
+              mockedParams.boundType,
+              mockedParams.newVersion,
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
       ).once();
       verify(mockedWrapper.getAvailableAddressesAsync()).once();
+      verify(mockedContract.getLowerSTVersionBounds).once();
+      verify(mockedLowerSTVersionBoundsMethod.callAsync()).once();
     });
   });
 
@@ -569,7 +638,7 @@ describe('ModuleFactoryWrapper', () => {
   describe('getLowerSTVersionBounds', () => {
     test('should get LowerSTVersionBounds', async () => {
       // Address expected
-      const expectedResult = [new BigNumber(1), new BigNumber(2)];
+      const expectedResult = [new BigNumber(1), new BigNumber(2), new BigNumber(3)];
       // Mocked method
       const mockedMethod = mock(MockedCallMethod);
       // Stub the method

src/contract_wrappers/modules/module_factory_wrapper.ts

@@ -102,6 +102,11 @@ interface ChangeTagsParams extends TxParams {
   tags: string[];
 }
 
+interface ChangeSTVersionBoundsParams extends TxParams {
+  boundType: BoundType;
+  newVersion: number[];
+}
+
 /**
  * This class includes the functionality related to interacting with the ModuleFactory contract.
  */
@@ -252,6 +257,32 @@ export default class ModuleFactoryWrapper extends ContractWrapper {
     );
   };
 
+  /**
+   * Change the ST VersionBounds
+   */
+  public changeSTVersionBounds = async (params: ChangeSTVersionBoundsParams) => {
+    await this.checkOnlyOwner(params.txData);
+    assert.assert(
+      params.boundType === BoundType.LowerBound || params.boundType === BoundType.UpperBound,
+      'Invalid bound type',
+    );
+    assert.assert(params.newVersion.length === 3, 'Invalid version, number array must have 3 elements');
+    const currentBound = BoundType.LowerBound === params.boundType ? await this.getLowerSTVersionBounds() : await this.getUpperSTVersionBounds();
+    for (let i = 0; i < 3; i += 1) {
+      if (params.boundType === BoundType.LowerBound) {
+        assert.assert(currentBound[i].isLessThanOrEqualTo(params.newVersion[i]), 'New Lower ST Bounds must be less than or equal to current');
+      } else {
+        assert.assert(currentBound[i].isGreaterThanOrEqualTo(params.newVersion[i]), 'New Upper ST Bounds must be greater than or equal to current');
+      }
+    }
+    return (await this.contract).changeSTVersionBounds.sendTransactionAsync(
+      params.boundType,
+      params.newVersion,
+      params.txData,
+      params.safetyFactor,
+    );
+  };
+
   /**
    * Get setup cost
    */

src/types.ts

@@ -132,6 +132,11 @@ export enum Partition {
   Undefined = 'UNDEFINED',
 }
 
+export enum BoundType {
+  LowerBound = 'lowerBound',
+  UpperBound = 'upperBound',
+}
+
 export enum PolymathContract {
   PolyToken = 'PolyToken',
   ModuleRegistry = 'ModuleRegistry',