Merge c15be96 into 3b65f6a

pooltogether · Aug 10, 2022 · 7e00acb · 7e00acb
2 parents 3b65f6a + c15be96
commit 7e00acb
Show file tree

Hide file tree

Showing 3 changed files with 96 additions and 8 deletions.
diff --git a/contracts/GaugeReward.sol b/contracts/GaugeReward.sol
@@ -229,19 +229,23 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall {
         if (_token != _rewardToken.token) {
             uint256 _currentTimestamp = block.timestamp;
 
-            gaugeRewardTokens[_gauge].push(
-                RewardToken({ token: _token, timestamp: uint64(_currentTimestamp) })
-            );
+            RewardToken memory _newRewardToken = RewardToken({
+                token: _token,
+                timestamp: uint64(_currentTimestamp)
+            });
+
+            gaugeRewardTokens[_gauge].push(_newRewardToken);
 
             emit RewardTokenPushed(_gauge, _token, _currentTimestamp);
 
-            _rewardToken = _currentRewardToken(_gauge);
+            _rewardToken = _newRewardToken;
         }
 
         uint256 _gaugeRewards = (_tokenAmount * stakerCut) / 1e9;
+        uint256 _gaugeBalance = gaugeController.getGaugeBalance(_gauge);
 
         // Exchange rate = amount / current staked amount on gauge
-        uint256 _exchangeRate = (_gaugeRewards * 1e18) / gaugeController.getGaugeBalance(_gauge);
+        uint256 _exchangeRate = _gaugeBalance > 0 ? (_gaugeRewards * 1e18) / _gaugeBalance : 0;
 
         gaugeRewardTokenExchangeRates[_gauge][_rewardToken.token][
             _rewardToken.timestamp
@@ -457,9 +461,9 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall {
 
         if (_rewards > 0) {
             userRewardTokenBalances[_user][_rewardToken.token] += _rewards;
-            emit RewardsClaimed(_gauge, _rewardToken.token, _user, _rewards, _exchangeRate);
         }
 
+        emit RewardsClaimed(_gauge, _rewardToken.token, _user, _rewards, _exchangeRate);
         return _rewards;
     }
 

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@pooltogether/v4-core",
-  "version": "1.4.0-beta.5",
+  "version": "1.4.0-beta.6",
   "description": "PoolTogether V4 Core Smart Contracts",
   "main": "index.js",
   "license": "GPL-3.0",

diff --git a/test/GaugeReward.test.ts b/test/GaugeReward.test.ts
@@ -186,6 +186,18 @@ describe('GaugeReward', () => {
                 );
         });
 
+        it('exchangeRate should be 0 if gaugeBalance is equal to 0', async () => {
+            expect(await afterSwap(poolToken, swapAmount, Zero))
+                .to.emit(gaugeReward, 'RewardsAdded')
+                .withArgs(
+                    gaugeAddress,
+                    poolToken.address,
+                    swapAmount,
+                    gaugeRewardAmount(swapAmount),
+                    Zero,
+                );
+        });
+
         it('should fail if not liquidator', async () => {
             await expect(afterSwap(poolToken, swapAmount, gaugeBalance, owner)).to.be.revertedWith(
                 'GReward/only-liquidator',
@@ -594,6 +606,28 @@ describe('GaugeReward', () => {
                 await gaugeReward.getRewards(gaugeAddress, lastPoolRewardToken, owner.address),
             ).to.equal(userRewardAmount(swapAmount, gaugeBalance, userStakeBalance));
         });
+
+        it('should return 0 if gaugeBalance is equal to 0', async () => {
+            await gaugeController.call(
+                gaugeReward,
+                'afterIncreaseGauge',
+                gaugeAddress,
+                owner.address,
+                userStakeBalance,
+            );
+
+            await afterSwap(usdcToken, swapAmount, Zero);
+
+            await gaugeController.mock.getUserGaugeBalance
+                .withArgs(gaugeAddress, owner.address)
+                .returns(userStakeBalance);
+
+            const currentRewardToken = await gaugeReward.currentRewardToken(gaugeAddress);
+
+            expect(
+                await gaugeReward.getRewards(gaugeAddress, currentRewardToken, owner.address),
+            ).to.equal(Zero);
+        });
     });
 
     describe('claim()', () => {
@@ -696,7 +730,7 @@ describe('GaugeReward', () => {
                 .returns(userStakeBalance);
 
             expect(await gaugeReward.claimAll(gaugeAddress, owner.address))
-                .to.not.emit(gaugeReward, 'RewardsClaimed')
+                .to.emit(gaugeReward, 'RewardsClaimed')
                 .withArgs(
                     gaugeAddress,
                     poolToken.address,
@@ -705,6 +739,32 @@ describe('GaugeReward', () => {
                     exchangeRate(swapAmount, gaugeBalance),
                 );
         });
+
+        it('should not claim any rewards if gaugeBalance is equal to 0', async () => {
+            await afterSwap(poolToken, swapAmount, Zero);
+
+            await gaugeController.call(
+                gaugeReward,
+                'afterIncreaseGauge',
+                gaugeAddress,
+                owner.address,
+                userStakeBalance,
+            );
+
+            await gaugeController.mock.getUserGaugeBalance
+                .withArgs(gaugeAddress, owner.address)
+                .returns(userStakeBalance);
+
+            expect(await gaugeReward.claimAll(gaugeAddress, owner.address))
+                .to.emit(gaugeReward, 'RewardsClaimed')
+                .withArgs(
+                    gaugeAddress,
+                    poolToken.address,
+                    owner.address,
+                    Zero,
+                    Zero,
+                );
+        });
     });
 
     describe('redeem()', () => {
@@ -746,5 +806,29 @@ describe('GaugeReward', () => {
                 .to.emit(gaugeReward, 'RewardsRedeemed')
                 .withArgs(owner.address, owner.address, rewardToken.token, gaugeRewardAmount);
         });
+
+        it('should not redeem any rewards if gauge balance is equal to 0', async () => {
+            await gaugeController.call(
+                gaugeReward,
+                'afterIncreaseGauge',
+                gaugeAddress,
+                owner.address,
+                userStakeBalance,
+            );
+
+            await afterSwap(poolToken, swapAmount, Zero);
+
+            await gaugeController.mock.getUserGaugeBalance
+                .withArgs(gaugeAddress, owner.address)
+                .returns(userStakeBalance);
+
+            const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress);
+
+            await gaugeReward.claim(gaugeAddress, rewardToken, owner.address);
+
+            expect(await gaugeReward.redeem(owner.address, rewardToken.token))
+                .to.emit(gaugeReward, 'RewardsRedeemed')
+                .withArgs(owner.address, owner.address, rewardToken.token, Zero);
+        });
     });
 });