fix: replicate changes inside etherDividend for all createDividends

including test changes and changes to wrapper checkIsValidDividend

Author: Victor Wiebe

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

@@ -65,6 +65,11 @@ describe('EtherDividendCheckpointWrapper', () => {
       when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
       when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
 
+      const expectedTotalSupplyResult = new BigNumber(1000);
+      const mockedSecurityTokenTotalSupplyMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenTotalSupplyMethod.callAsync()).thenResolve(expectedTotalSupplyResult);
+      when(mockedSecurityTokenContract.totalSupply).thenReturn(instance(mockedSecurityTokenTotalSupplyMethod));
+
       // Mock web3 wrapper owner
       when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
 
@@ -115,10 +120,12 @@ describe('EtherDividendCheckpointWrapper', () => {
       ).once();
       verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
       verify(mockedSecurityTokenContract.owner).once();
-      verify(mockedContract.securityToken).once();
-      verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
-      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
+      verify(mockedContract.securityToken).twice();
+      verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
+      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
       verify(mockedWrapper.getAvailableAddressesAsync()).once();
+      verify(mockedSecurityTokenTotalSupplyMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.totalSupply).once();
     });
   });
 
@@ -141,6 +148,13 @@ describe('EtherDividendCheckpointWrapper', () => {
       when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
       when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
 
+      const expectedTotalSupplyResult = new BigNumber(1000);
+      const mockedSecurityTokenTotalSupplyMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenTotalSupplyMethod.callAsync(objectContaining(new BigNumber(checkpointId)))).thenResolve(
+        expectedTotalSupplyResult,
+      );
+      when(mockedSecurityTokenContract.totalSupplyAt).thenReturn(instance(mockedSecurityTokenTotalSupplyMethod));
+
       // Mock web3 wrapper owner
       when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
 
@@ -208,6 +222,8 @@ describe('EtherDividendCheckpointWrapper', () => {
       verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
       verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
       verify(mockedWrapper.getAvailableAddressesAsync()).once();
+      verify(mockedSecurityTokenTotalSupplyMethod.callAsync(objectContaining(new BigNumber(checkpointId)))).once();
+      verify(mockedSecurityTokenContract.totalSupplyAt).once();
     });
   });
 
@@ -230,6 +246,24 @@ describe('EtherDividendCheckpointWrapper', () => {
       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);
+
       // Mock web3 wrapper owner
       when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
 
@@ -300,6 +334,15 @@ describe('EtherDividendCheckpointWrapper', () => {
       verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
       verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
       verify(mockedWrapper.getAvailableAddressesAsync()).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);
     });
   });
 
@@ -321,6 +364,20 @@ describe('EtherDividendCheckpointWrapper', () => {
       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()).thenResolve(expectedTotalSupplyResult);
+      when(mockedSecurityTokenContract.totalSupply).thenReturn(instance(mockedSecurityTokenTotalSupplyMethod));
+
+      const expectedSecurityTokenBalanceOfResult = new BigNumber(10);
+      const mockedSecurityTokenBalanceOfMethod = mock(MockedCallMethod);
+      function whenBalanceOf(addr: string) {
+        when(mockedSecurityTokenBalanceOfMethod.callAsync(addr)).thenResolve(expectedSecurityTokenBalanceOfResult);
+      }
+      when(mockedSecurityTokenContract.balanceOf).thenReturn(instance(mockedSecurityTokenBalanceOfMethod));
+      excluded.map(whenBalanceOf);
+
       // Mock web3 wrapper owner
       when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
 
@@ -374,10 +431,17 @@ describe('EtherDividendCheckpointWrapper', () => {
       ).once();
       verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
       verify(mockedSecurityTokenContract.owner).once();
-      verify(mockedContract.securityToken).once();
-      verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
-      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
+      verify(mockedContract.securityToken).twice();
+      verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
+      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
       verify(mockedWrapper.getAvailableAddressesAsync()).once();
+      verify(mockedSecurityTokenTotalSupplyMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.totalSupply).once();
+      function verifyBalanceOf(addr: string) {
+        verify(mockedSecurityTokenBalanceOfMethod.callAsync(addr)).once();
+      }
+      verify(mockedSecurityTokenContract.balanceOf).times(excluded.length);
+      excluded.map(verifyBalanceOf);
     });
   });
 

src/contract_wrappers/modules/checkpoint/ether_dividend_checkpoint_wrapper.ts

@@ -398,10 +398,47 @@ export default class EtherDividendCheckpointWrapper extends DividendCheckpointWr
     assert.assert(expiry > maturity, 'Expiry before maturity');
     assert.isFutureDate(expiry, 'Expiry in past');
     assert.isBigNumberGreaterThanZero(value, '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.assert(name.length > 0, 'The name can not be empty');
+
+    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',
+    );
   };
 }