fix: dividend changes fo excluded and checkpoint id

Updating first test with checkpoint and exclusions

Author: Victor Wiebe

src/contract_wrappers/modules/checkpoint/__tests__/erc20_dividend_checkpoint_wrapper.test.ts

@@ -315,6 +315,24 @@ describe('ERC20DividendCheckpointWrapper', () => {
       when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
       when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
 
+      const excluded = ['0x9999999999999999999999999999999999999999', '0x8888888888888888888888888888888888888888'];
+      const expectedTotalSupplyResult = new BigNumber(1000);
+      const mockedSecurityTokenTotalSupplyMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenTotalSupplyMethod.callAsync(objectContaining(new BigNumber(checkpointId)))).thenResolve(
+        expectedTotalSupplyResult,
+      );
+      when(mockedSecurityTokenContract.totalSupplyAt).thenReturn(instance(mockedSecurityTokenTotalSupplyMethod));
+
+      const expectedSecurityTokenBalanceOfResult = new BigNumber(10);
+      const mockedSecurityTokenBalanceOfMethod = mock(MockedCallMethod);
+      function whenBalanceOf (addr: string){
+        when(
+            mockedSecurityTokenBalanceOfMethod.callAsync(addr, objectContaining(new BigNumber(checkpointId))),
+        ).thenResolve(expectedSecurityTokenBalanceOfResult);
+        when(mockedSecurityTokenContract.balanceOfAt).thenReturn(instance(mockedSecurityTokenBalanceOfMethod));
+      }
+      excluded.map(whenBalanceOf);
+
       const expectedBalanceOfResult = new BigNumber(100);
       const mockedBalanceOfAddressMethod = mock(MockedCallMethod);
       when(mockedERC20DetailedContract.balanceOf).thenReturn(instance(mockedBalanceOfAddressMethod));
@@ -411,6 +429,15 @@ describe('ERC20DividendCheckpointWrapper', () => {
       verify(mockedContractFactory.getERC20DetailedContract(token)).twice();
       verify(mockedERC20DetailedContract.decimals).once();
       verify(mockedDecimalsMethod.callAsync()).once();
+      verify(mockedSecurityTokenTotalSupplyMethod.callAsync(objectContaining(new BigNumber(checkpointId)))).once();
+      verify(mockedSecurityTokenContract.totalSupplyAt).once();
+      function verifyBalanceOf (addr: string){
+        verify(
+            mockedSecurityTokenBalanceOfMethod.callAsync(addr, objectContaining(new BigNumber(checkpointId))),
+        ).once();
+      }
+      excluded.map(verifyBalanceOf);
+      verify(mockedSecurityTokenContract.balanceOfAt).times(excluded.length);
     });
   });
 

src/contract_wrappers/modules/checkpoint/erc20_dividend_checkpoint_wrapper.ts

@@ -359,8 +359,9 @@ export default class ERC20DividendCheckpointWrapper extends DividendCheckpointWr
     assert.assert(expiry > maturity, 'Expiry before maturity');
     assert.isFutureDate(expiry, 'Expiry in past');
     assert.isBigNumberGreaterThanZero(amount, 'No dividend sent');
+    const stContract = await this.securityTokenContract();
     if (checkpointId !== undefined) {
-      const currentCheckpointId = await (await this.securityTokenContract()).currentCheckpointId.callAsync();
+      const currentCheckpointId = await stContract.currentCheckpointId.callAsync();
       assert.assert(checkpointId < new BigNumber(currentCheckpointId).toNumber(), 'Invalid checkpoint');
     }
     assert.isNonZeroETHAddressHex('token', token);
@@ -371,5 +372,44 @@ export default class ERC20DividendCheckpointWrapper extends DividendCheckpointWr
     const erc20TokenAllowance = await erc20Detailed.allowance.callAsync(callerAddress, token);
     assert.assert(erc20TokenAllowance.isGreaterThanOrEqualTo(amount), 'Your allowance is less than dividend amount');
     assert.assert(erc20TokenBalance.isGreaterThanOrEqualTo(amount), 'Your balance is less than dividend amount');
+
+    function checkExcludedAssertions(addr: string) {
+      assert.isNonZeroETHAddressHex('Excluded Address', addr);
+    }
+
+    if (excluded) {
+      excluded.map(checkExcludedAssertions);
+      assert.areThereDuplicatedStrings('Excluded Addresses', excluded);
+    }
+    let currentSupply;
+    let excludedSupply = new BigNumber(0);
+    if (checkpointId) {
+      currentSupply = await stContract.totalSupplyAt.callAsync(new BigNumber(checkpointId));
+      if (excluded) {
+        const promises = [];
+        for (let i = 0; i < excluded.length; i += 1) {
+          excludedSupply = excludedSupply.plus(
+            promises.push(stContract.balanceOfAt.callAsync(excluded[i], new BigNumber(checkpointId))),
+          );
+        }
+        excludedSupply = BigNumber.sum.apply(null, await Promise.all(promises));
+      }
+    } else {
+      currentSupply = await stContract.totalSupply.callAsync();
+      if (excluded) {
+        const promises = [];
+        for (let i = 0; i < excluded.length; i += 1) {
+          excludedSupply = excludedSupply.plus(
+              promises.push(stContract.balanceOf.callAsync(excluded[i])),
+          );
+        }
+        excludedSupply = BigNumber.sum.apply(null, await Promise.all(promises));
+      }
+    }
+    assert.assert(!currentSupply.isZero(), 'Invalid supply, must be greater than 0');
+    assert.assert(
+      currentSupply.isGreaterThan(excludedSupply),
+      'Invalid supply, current supply must be greater than excluded supply',
+    );
   };
 }