chore: expose votes from FeaturedVotingContract

packages/contracts/contracts/FeaturedVotingContract.sol

@@ -135,7 +135,7 @@ contract FeaturedVotingContract {
     function initializeVoting(bytes calldata publicKey, uint256 voteAmount) public {
         require(votings.length == 0 || votings[votings.length - 1].finalized, 'vote already ongoing');
         require(directory.isCommunityInDirectory(publicKey), 'community not in directory');
-        require(!_isInCooldownPeriod(publicKey), 'community has been featured recently');
+        require(!isInCooldownPeriod(publicKey), 'community has been featured recently');
         require(token.balanceOf(msg.sender) >= voteAmount, 'not enough token');
 
         uint votingID = votings.length + 1;
@@ -178,11 +178,19 @@ contract FeaturedVotingContract {
         }
     }
 
+    function getVotings() public view returns (Voting[] memory) {
+        return votings;
+    }
+
+    function getVotesByVotingId(uint256 votingID) public view returns (Vote[] memory) {
+        return votesByVotingID[votingID];
+    }
+
     function _min(uint256 a, uint256 b) private pure returns (uint256) {
         return a < b ? a : b;
     }
 
-    function _isInCooldownPeriod(bytes calldata publicKey) private view returns (bool) {
+    function isInCooldownPeriod(bytes calldata publicKey) public view returns (bool) {
         uint256 votingsCount = _min(votings.length, cooldownPeriod);
         for (uint256 i = 0; i < votingsCount; i++) {
             bytes[] storage featured = featuredByVotingID[votings[votings.length - i - 1].id];
@@ -270,7 +278,7 @@ contract FeaturedVotingContract {
             return;
         }
 
-        if (_isInCooldownPeriod(vote.community)) {
+        if (isInCooldownPeriod(vote.community)) {
             emit CommunityFeaturedRecently(vote.community, vote.voter);
             return;
         }

packages/contracts/test/3.featuredVotingContract.test.ts

@@ -22,7 +22,7 @@ const publicKeys = [
 const votingLength = 1000
 const votingVerificationLength = 200
 const featuredPerVotingCount = 3
-const cooldownPeriod = 1
+const cooldownPeriod = 2
 const votingWithVerificationLength = votingLength + votingVerificationLength
 
 const typedData = {
@@ -168,38 +168,6 @@ describe('FeaturedVotingContract', () => {
         'community has been featured recently'
       )
     })
-
-    it('should initialize voting for community when cooldown period has passed', async () => {
-      const { featuredVotingContract } = await loadFixture(fixture)
-
-      // first initialize voting with first pubkey
-      await expect(featuredVotingContract.initializeVoting(publicKeys[0], 100)).to.emit(
-        featuredVotingContract,
-        'VotingStarted'
-      )
-
-      // fast forward to finalize first voting
-      await time.increase(votingWithVerificationLength + 1)
-      await expect(featuredVotingContract.finalizeVoting()).to.emit(featuredVotingContract, 'VotingFinalized')
-      await expect((await featuredVotingContract.votings(0)).finalized).to.eq(true)
-
-      // the `cooldownPeriod` is `1` so we need at least one voting
-      // that doesn't feature `publicKeys[0]` to start a new
-      await expect(featuredVotingContract.initializeVoting(publicKeys[1], 100)).to.emit(
-        featuredVotingContract,
-        'VotingStarted'
-      )
-
-      // fast forward again to finalize second voting (which does not include `publicKeys[0]`)
-      await time.increase(votingWithVerificationLength + 1)
-      await expect(featuredVotingContract.finalizeVoting()).to.emit(featuredVotingContract, 'VotingFinalized')
-
-      // initializing vote for `publicKey[0]` should be fine now
-      await expect(featuredVotingContract.initializeVoting(publicKeys[0], 100)).to.emit(
-        featuredVotingContract,
-        'VotingStarted'
-      )
-    })
   })
 
   describe('#castVotes()', () => {
@@ -249,4 +217,30 @@ describe('FeaturedVotingContract', () => {
       expect(await directoryContract.getFeaturedCommunities()).to.deep.eq([publicKeys[3], publicKeys[1], publicKeys[0]])
     })
   })
+
+  describe('#isInCooldownPeriod', () => {
+    it('should return false for not recently featured community', async () => {
+      const { featuredVotingContract } = await loadFixture(fixture)
+      expect(await featuredVotingContract.isInCooldownPeriod(publicKeys[0])).to.eq(false)
+    })
+
+    it('should return true for recently featured community', async () => {
+      const { featuredVotingContract } = await loadFixture(fixture)
+
+      await featuredVotingContract.initializeVoting(publicKeys[0], 100)
+      await time.increase(votingWithVerificationLength + 1)
+      await featuredVotingContract.finalizeVoting()
+
+      for (let i = 0; i < cooldownPeriod; i++) {
+        expect(await featuredVotingContract.isInCooldownPeriod(publicKeys[0])).to.eq(true)
+
+        await featuredVotingContract.initializeVoting(publicKeys[i + 1], 100)
+        await time.increase(votingWithVerificationLength + 1)
+        await featuredVotingContract.finalizeVoting()
+      }
+
+      // the cooldown period has ended here
+      expect(await featuredVotingContract.isInCooldownPeriod(publicKeys[0])).to.eq(false)
+    })
+  })
 })