feat: 🎸 addLockUpByName

Author: Victor Wiebe

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

@@ -814,6 +814,122 @@ describe('LockUpTransferManagerWrapper', () => {
     });
   });
 
+  describe('addLockUpByName', () => {
+    test('should call addLockUpByName', async () => {
+      const expectedOwnerResult = '0x8888888888888888888888888888888888888888';
+      const expectedLockUpInvestorAddress = '0x4444444444444444444444444444444444444444';
+      const lockupName = 'Lockup3';
+      const expectedDecimalsResult = new BigNumber(18);
+      const expectedLockupAmount = valueToWei(new BigNumber(10), expectedDecimalsResult);
+      const expectedStartTime = dateToBigNumber(new Date(2030, 1));
+      const expectedLockUpPeriodSeconds = new BigNumber(3600);
+      const expectedReleaseFrequencySeconds = new BigNumber(60);
+      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 expectedGetLockupsNamesToUserResult = stringArrayToBytes32Array(['Lockup1', 'Lockup2']);
+      const mockedGetLockupsNamesToUserParams = {
+        user: expectedLockUpInvestorAddress,
+      };
+      // Mocked method
+      const mockedGetLockupsNamesToUserMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.getLockupsNamesToUser).thenReturn(instance(mockedGetLockupsNamesToUserMethod));
+      // Stub the request
+      when(mockedGetLockupsNamesToUserMethod.callAsync(mockedGetLockupsNamesToUserParams.user)).thenResolve(
+        expectedGetLockupsNamesToUserResult,
+      );
+
+      const mockedParams = {
+        userAddress: expectedLockUpInvestorAddress,
+        lockupName,
+        txData: {},
+        safetyFactor: 10,
+      };
+      const expectedResult = getMockedPolyResponse();
+      // Mocked method
+      const mockedMethod = mock(MockedSendMethod);
+      // Stub the method
+      when(mockedContract.addLockUpByName).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(
+        mockedMethod.sendTransactionAsync(
+          mockedParams.userAddress,
+          objectContaining(stringToBytes32(mockedParams.lockupName)),
+          mockedParams.txData,
+          mockedParams.safetyFactor,
+        ),
+      ).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.addLockUpByName(mockedParams);
+
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.addLockUpByName).once();
+      verify(
+        mockedMethod.sendTransactionAsync(
+          mockedParams.userAddress,
+          objectContaining(stringToBytes32(mockedParams.lockupName)),
+          mockedParams.txData,
+          mockedParams.safetyFactor,
+        ),
+      ).once();
+      verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.owner).once();
+      verify(mockedSecurityTokenDecimalsMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.decimals).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();
+      verify(mockedContract.getLockupsNamesToUser).once();
+      verify(mockedGetLockupsNamesToUserMethod.callAsync(mockedGetLockupsNamesToUserParams.user)).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

@@ -175,6 +175,11 @@ interface AddNewLockUpTypeMultiParams extends TxParams {
   lockupNames: string[];
 }
 
+interface AddLockUpByNameParams extends TxParams {
+  userAddress: string;
+  lockupName: string;
+}
+
 // // Return types ////
 interface LockUp {
   lockupAmount: BigNumber;
@@ -421,6 +426,21 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
     );
   };
 
+
+  /*
+   * addLockUpByName
+   */
+  public addLockUpByName = async (params: AddLockUpByNameParams) => {
+    assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
+    await this.checkAddLockUpByName(params);
+    return (await this.contract).addLockUpByName.sendTransactionAsync(
+        params.userAddress,
+        stringToBytes32(params.lockupName),
+        params.txData,
+        params.safetyFactor,
+    );
+  };
+
   /**
    * Subscribe to an event type emitted by the contract.
    * @return Subscription token used later to unsubscribe
@@ -480,4 +500,15 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
     );
     assert.isBigNumberGreaterThanZero(params.lockupAmount, 'Lockup amount should be greater than 0');
   };
+
+  private checkAddLockUpByName = async (params: AddLockUpByNameParams) => {
+    assert.assert(params.lockupName.length > 0, 'Lockup Name cannot be empty string');
+    assert.isNonZeroETHAddressHex('User Address', params.userAddress);
+    const lockup = await this.getLockUp({ lockupName: params.lockupName });
+    assert.isFutureDate(lockup.startTime, 'Start time must be in the future');
+    const lockupNames = await this.getLockupsNamesToUser({user: params.userAddress});
+    console.log(lockupNames);
+    console.log(params.lockupName);
+    assert.assert(!lockupNames.includes(params.lockupName), 'User already added to this lockup name');
+  };
 }