feat: 🎸 addNewLockUpType method and tests

Author: Victor Wiebe

src/contract_wrappers/modules/transfer_manager/__tests__/lock_up_transfer_manager_wrapper.test.ts

@@ -592,6 +592,112 @@ describe('LockUpTransferManagerWrapper', () => {
     });
   });
 
+
+  describe('addNewLockUpType', () => {
+    test('should call addNewLockUpType', async () => {
+      const expectedOwnerResult = '0x8888888888888888888888888888888888888888';
+      const lockupName= 'Lockup1';
+      const expectedDecimalsResult = new BigNumber(18);
+      const expectedLockupAmount = valueToWei(new BigNumber(0), expectedDecimalsResult);
+      const expectedStartTime = new BigNumber(0);
+      const expectedLockUpPeriodSeconds = new BigNumber(0);
+      const expectedReleaseFrequencySeconds = new BigNumber(0);
+      const expectedUnlockedAmount = new BigNumber(0);
+      const expectedGetLockupResult = [
+        expectedLockupAmount,
+        expectedStartTime,
+        expectedLockUpPeriodSeconds,
+        expectedReleaseFrequencySeconds,
+        expectedUnlockedAmount,
+      ];
+      const mockedGetLockupParams = {
+        lockupName,
+      };
+
+      // Security Token Address expected
+      const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
+      // Setup get Security Token Address
+      const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
+      when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
+      when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
+      when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
+          instance(mockedSecurityTokenContract),
+      );
+      const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
+      when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
+      const mockedSecurityTokenOwnerMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
+      when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
+
+      // Mock web3 wrapper owner
+      when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
+
+      // Mocked method
+      const mockedGetLockupMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.getLockUp).thenReturn(instance(mockedGetLockupMethod));
+      // Stub the request
+      when(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName)))).thenResolve(
+          expectedGetLockupResult,
+      );
+
+      const mockedParams = {
+        lockupAmount: new BigNumber(100),
+        startTime: new Date(2030, 1),
+        lockUpPeriodSeconds: new BigNumber(3600),
+        releaseFrequencySeconds: new BigNumber(60),
+        lockupName,
+        txData: {},
+        safetyFactor: 10,
+      };
+      const expectedResult = getMockedPolyResponse();
+      // Mocked method
+      const mockedMethod = mock(MockedSendMethod);
+      // Stub the method
+      when(mockedContract.addNewLockUpType).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(
+          mockedMethod.sendTransactionAsync(
+              objectContaining(mockedParams.lockupAmount),
+              objectContaining(dateToBigNumber(mockedParams.startTime)),
+              objectContaining(mockedParams.lockUpPeriodSeconds),
+              objectContaining(mockedParams.releaseFrequencySeconds),
+              stringToBytes32(mockedParams.lockupName),
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
+      ).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.addNewLockUpType(mockedParams);
+
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.addNewLockUpType).once();
+      verify(
+          mockedMethod.sendTransactionAsync(
+              objectContaining(mockedParams.lockupAmount),
+              objectContaining(dateToBigNumber(mockedParams.startTime)),
+              objectContaining(mockedParams.lockUpPeriodSeconds),
+              objectContaining(mockedParams.releaseFrequencySeconds),
+              stringToBytes32(mockedParams.lockupName),
+              mockedParams.txData,
+              mockedParams.safetyFactor,
+          ),
+      ).once();
+      verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.owner).once();
+      verify(mockedContract.securityToken).twice();
+      verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
+      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
+      verify(mockedWrapper.getAvailableAddressesAsync()).once();
+      verify(mockedContract.getLockUp).once();
+      verify(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName)))).once();
+    });
+  });
+
   describe('verifyTransfer', () => {
     test('should verify Transfer', async () => {
       const statusCode = new BigNumber(2);

src/contract_wrappers/modules/transfer_manager/lock_up_transfer_manager_wrapper.ts

@@ -34,6 +34,8 @@ import {
   bigNumberToDate,
   bytes32ArrayToStringArray,
   bytes32ToString,
+  dateToBigNumber,
+  parseModuleTypeValue,
   parsePermBytes32Value,
   parseTransferResult,
   stringToBytes32,
@@ -155,6 +157,14 @@ interface VerifyTransferParams {
   data: string;
 }
 
+interface AddNewLockUpTypeParams extends TxParams {
+  lockupAmount: BigNumber;
+  startTime: Date;
+  lockUpPeriodSeconds: BigNumber;
+  releaseFrequencySeconds: BigNumber;
+  lockupName: string;
+}
+
 // // Return types ////
 interface LockUp {
   lockupAmount: BigNumber;
@@ -342,6 +352,23 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
     };
   };
 
+  /*
+   * addNewLockUpType
+   */
+  public addNewLockUpType = async (params: AddNewLockUpTypeParams) => {
+    assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
+    await this.checkAddNewLockUpType(params);
+    return (await this.contract).addNewLockUpType.sendTransactionAsync(
+      params.lockupAmount,
+      dateToBigNumber(params.startTime),
+      params.lockUpPeriodSeconds,
+      params.releaseFrequencySeconds,
+      stringToBytes32(params.lockupName),
+      params.txData,
+      params.safetyFactor,
+    );
+  };
+
   /**
    * Subscribe to an event type emitted by the contract.
    * @return Subscription token used later to unsubscribe
@@ -388,4 +415,17 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
     );
     return logs;
   };
+
+  private checkAddNewLockUpType = async (params: AddNewLockUpTypeParams) => {
+    assert.assert(params.lockupName.length > 0, 'Lockup Name cannot be empty string');
+    const lockup = await this.getLockUp({ lockupName: params.lockupName });
+    assert.isBigNumberZero(lockup.lockupAmount, 'LockUp already exists');
+    assert.isFutureDate(params.startTime, 'Start time must be in the future');
+    assert.isBigNumberGreaterThanZero(params.lockUpPeriodSeconds, 'Lockup period in seconds should be greater than 0');
+    assert.isBigNumberGreaterThanZero(
+      params.releaseFrequencySeconds,
+      'Release frequency in seconds should be greater than 0',
+    );
+    assert.isBigNumberGreaterThanZero(params.lockupAmount, 'Lockup amount should be greater than 0');
+  };
 }