From 5a61ae411c962fd249821682fbe34502cd2c36b4 Mon Sep 17 00:00:00 2001 From: Pierrick Turelier Date: Thu, 26 May 2022 17:57:16 -0500 Subject: [PATCH] feat(GaugeReward): refactor claim function --- contracts/GaugeReward.sol | 290 ++++++++++++++++++++++++++------------ test/GaugeReward.test.ts | 245 ++++++++++++++++++++++++++++---- 2 files changed, 418 insertions(+), 117 deletions(-) diff --git a/contracts/GaugeReward.sol b/contracts/GaugeReward.sol index f85edd43..69adf651 100644 --- a/contracts/GaugeReward.sol +++ b/contracts/GaugeReward.sol @@ -30,23 +30,25 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { mapping(address => mapping(IERC20 => uint256)) public userTokenRewardBalances; /** - * @notice Tracks user token gauge exchange rate - * @dev user => token => gauge => exchange rate + * @notice Tracks reward token exchange rate per user and gauge + * @dev user => gauge => reward token address => reward token timestamp => exchange rate */ - mapping(address => mapping(IERC20 => mapping(address => uint256))) - public userTokenGaugeExchangeRates; + mapping(address => mapping(address => mapping(IERC20 => mapping(uint64 => uint256)))) + public userGaugeRewardTokenExchangeRates; /** - * @notice Tracks user last claimed timestamp - * @dev user => timestamp + * @notice Tracks user last claimed timestamp per gauge and reward token + * @dev user => gauge => reward token address => timestamp */ - mapping(address => uint256) public userLastClaimedTimestamp; + mapping(address => mapping(address => mapping(address => uint256))) + public userGaugeRewardTokenLastClaimedTimestamp; /** - * @notice Tracks token gauge exchange rates - * @dev token => gauge => exchange rate + * @notice Tracks reward token exchange rates per gauge + * @dev gauge => reward token address => reward token timestamp => exchange rate */ - mapping(IERC20 => mapping(address => uint256)) public tokenGaugeExchangeRates; + mapping(address => mapping(IERC20 => mapping(uint64 => uint256))) + public gaugeRewardTokenExchangeRates; /** * @notice RewardToken struct @@ -185,6 +187,24 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { return _currentRewardToken(_gauge); } + /** + * @notice Get user rewards for a given gauge and token. + * @param _gauge Address of the gauge to get rewards for + * @param _rewardToken Reward token to get rewards for + * @param _user Address of the user to get rewards for + * @return Amount of rewards for the given gauge and token + */ + function getRewards( + address _gauge, + RewardToken memory _rewardToken, + address _user + ) external view returns (uint256) { + uint256 _stakeBalance = gaugeController.getUserGaugeBalance(_gauge, _user); + (uint256 _rewards, ) = _getRewards(_gauge, _rewardToken, _user, _stakeBalance); + + return _rewards; + } + /** * @notice Records exchange rate after swapping an amount of `ticket` for `token`. * @dev Called by the liquidator contract anytime tokens are liquidated. @@ -204,8 +224,18 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { address _gauge = address(_ticket); - if (_token != _currentRewardToken(_gauge).token) { - _pushRewardToken(_gauge, _token); + RewardToken memory _rewardToken = _currentRewardToken(_gauge); + + if (_token != _rewardToken.token) { + uint256 _currentTimestamp = block.timestamp; + + gaugeRewardTokens[_gauge].push( + RewardToken({ token: _token, timestamp: uint64(_currentTimestamp) }) + ); + + emit RewardTokenPushed(_gauge, _token, _currentTimestamp); + + _rewardToken = _currentRewardToken(_gauge); } uint256 _gaugeRewards = (_tokenAmount * stakerCut) / 1e9; @@ -213,7 +243,9 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { // Exchange rate = amount / current staked amount on gauge uint256 _exchangeRate = (_gaugeRewards * 1e18) / gaugeController.getGaugeBalance(_gauge); - tokenGaugeExchangeRates[_token][_gauge] += _exchangeRate; + gaugeRewardTokenExchangeRates[_gauge][_rewardToken.token][ + _rewardToken.timestamp + ] += _exchangeRate; emit RewardsAdded(_gauge, _token, _tokenAmount, _gaugeRewards, _exchangeRate); } @@ -224,7 +256,7 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { address _user, uint256 _oldStakeBalance ) external override onlyGaugeController { - _claim(_gauge, _user, _oldStakeBalance); + _claimAll(_gauge, _user, _oldStakeBalance); } /// @inheritdoc IGaugeReward @@ -233,20 +265,32 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { address _user, uint256 _oldStakeBalance ) external override onlyGaugeController { - _claim(_gauge, _user, _oldStakeBalance); + _claimAll(_gauge, _user, _oldStakeBalance); } /** - * @notice Claim user rewards for a given gauge. + * @notice Claim user rewards for a given gauge and reward token. * @param _gauge Address of the gauge to claim rewards for + * @param _rewardToken Reward token to claim rewards for * @param _user Address of the user to claim rewards for */ function claim( address _gauge, + RewardToken memory _rewardToken, address _user ) external { uint256 _stakeBalance = gaugeController.getUserGaugeBalance(_gauge, _user); - _claim(_gauge, _user, _stakeBalance); + _claim(_gauge, _rewardToken, _user, _stakeBalance); + } + + /** + * @notice Claim all user rewards for a given gauge. + * @param _gauge Address of the gauge to claim rewards for + * @param _user Address of the user to claim rewards for + */ + function claimAll(address _gauge, address _user) external { + uint256 _stakeBalance = gaugeController.getUserGaugeBalance(_gauge, _user); + _claimAll(_gauge, _user, _stakeBalance); } /** @@ -286,119 +330,189 @@ contract GaugeReward is IGaugeReward, IPrizePoolLiquidatorListener, Multicall { } /** - * @notice Claim user rewards for a given gauge and token. - * @param _gauge Address of the gauge to claim rewards for - * @param _token Address of the token to claim rewards for - * @param _user Address of the user to claim rewards for - * @param _stakeBalance User stake balance - * @param _eligibleForPastRewards Whether user is eligible for past rewards or not + * @notice Get user last claimed timestamp for a given gauge and reward token + * @param _user Address of the user to set last claimed timestamp for + * @param _gauge Address of the gauge to set last claimed timestamp for + * @param _rewardTokenAddress Address of the reward token to set last claimed timestamp for + * @return Last claimed timestamp for the given gauge and reward token */ - function _claimRewards( + function _getUserGaugeRewardTokenLastClaimedTimestamp( + address _user, address _gauge, - IERC20 _token, + address _rewardTokenAddress + ) internal view returns (uint256) { + return userGaugeRewardTokenLastClaimedTimestamp[_user][_gauge][_rewardTokenAddress]; + } + + /** + * @notice Set user last claimed timestamp for a given gauge and reward token + * @param _user Address of the user to set last claimed timestamp for + * @param _gauge Address of the gauge to set last claimed timestamp for + * @param _rewardTokenAddress Address of the reward token to set last claimed timestamp for + */ + function _setUserGaugeRewardTokenLastClaimedTimestamp( address _user, - uint256 _stakeBalance, - bool _eligibleForPastRewards - ) internal returns (uint256) { - uint256 _previousExchangeRate = userTokenGaugeExchangeRates[_user][_token][_gauge]; - uint256 _currentExchangeRate = tokenGaugeExchangeRates[_token][_gauge]; + address _gauge, + address _rewardTokenAddress + ) internal { + userGaugeRewardTokenLastClaimedTimestamp[_user][_gauge][_rewardTokenAddress] = uint64( + block.timestamp + ); + } - if (!_eligibleForPastRewards && _previousExchangeRate == 0) { - _previousExchangeRate = _currentExchangeRate; - } + /** + * @notice Get user rewards for a given gauge and token. + * @param _gauge Address of the gauge to get rewards for + * @param _rewardToken Reward token to get rewards for + * @param _user Address of the user to get rewards for + * @param _stakeBalance User stake balance + * @return _rewards Amount of rewards for the given gauge and token + * @return _exchangeRate Current exchange rate for the given gauge and token + */ + function _getRewards( + address _gauge, + RewardToken memory _rewardToken, + address _user, + uint256 _stakeBalance + ) internal view returns (uint256 _rewards, uint256 _exchangeRate) { + uint256 _previousExchangeRate = userGaugeRewardTokenExchangeRates[_user][_gauge][ + _rewardToken.token + ][_rewardToken.timestamp]; + + uint256 _currentExchangeRate = gaugeRewardTokenExchangeRates[_gauge][_rewardToken.token][ + _rewardToken.timestamp + ]; + + uint256 _userLastClaimedTimestamp = _getUserGaugeRewardTokenLastClaimedTimestamp( + _user, + _gauge, + address(_rewardToken.token) + ); - // Rewards = deltaExchangeRate * stakeBalance - uint256 _rewards = ((_currentExchangeRate - _previousExchangeRate) * _stakeBalance) / 1e18; + if (_userLastClaimedTimestamp == 0) { + RewardToken[] memory _gaugeRewardTokens = gaugeRewardTokens[_gauge]; + uint256 _gaugeRewardTokensLength = _gaugeRewardTokens.length; + + if (_gaugeRewardTokensLength > 1) { + RewardToken memory _previousRewardToken = _gaugeRewardTokens[ + _gaugeRewardTokensLength - 1 + ]; + + // User may have claimed rewards for the previous reward token + _userLastClaimedTimestamp = _getUserGaugeRewardTokenLastClaimedTimestamp( + _user, + _gauge, + address(_previousRewardToken.token) + ); + } - // Record current exchange rate - userTokenGaugeExchangeRates[_user][_token][_gauge] = _currentExchangeRate; + if (_userLastClaimedTimestamp == 0) { + // User may have claimed rewards before any tokens were set for the gauge + _userLastClaimedTimestamp = _getUserGaugeRewardTokenLastClaimedTimestamp( + _user, + _gauge, + address(0) + ); + } + } - // Skip event and rewards accrual if rewards are equal to zero - if (_rewards > 0) { - userTokenRewardBalances[_user][_token] += _rewards; + bool _isEligibleForPastRewards = _userLastClaimedTimestamp > 0 && + _rewardToken.timestamp > _userLastClaimedTimestamp; - emit RewardsClaimed(_gauge, _token, _user, _rewards, _currentExchangeRate); + // User is not eligible for any rewards, we return early + if (!_isEligibleForPastRewards && _previousExchangeRate == 0) { + return (0, _currentExchangeRate); } - return _rewards; + return ( + // Rewards = deltaExchangeRate * stakeBalance + ((_currentExchangeRate - _previousExchangeRate) * _stakeBalance) / 1e18, + _currentExchangeRate + ); } /** - * @notice Claim user past rewards for a given gauge. - * @dev Go through all the past reward tokens for the given gauge and claim rewards. + * @notice Claim user rewards for a given gauge and token. * @param _gauge Address of the gauge to claim rewards for + * @param _rewardToken Reward token to get rewards for * @param _user Address of the user to claim rewards for * @param _stakeBalance User stake balance */ - function _claimPastRewards( + function _claimRewards( address _gauge, + RewardToken memory _rewardToken, address _user, uint256 _stakeBalance - ) internal returns (RewardToken memory) { - uint256 _userLastClaimedTimestamp = userLastClaimedTimestamp[_user]; - uint256 _gaugeRewardTokensLength = gaugeRewardTokens[_gauge].length; - - RewardToken memory _rewardToken; - RewardToken memory _latestRewardToken; - - if (_gaugeRewardTokensLength > 0) { - uint256 i = _gaugeRewardTokensLength; + ) internal returns (uint256) { + (uint256 _rewards, uint256 _exchangeRate) = _getRewards( + _gauge, + _rewardToken, + _user, + _stakeBalance + ); - while (i > 0) { - i = i - 1; - _rewardToken = gaugeRewardTokens[_gauge][i]; + userGaugeRewardTokenExchangeRates[_user][_gauge][_rewardToken.token][ + _rewardToken.timestamp + ] = _exchangeRate; - if (i == _gaugeRewardTokensLength - 1) { - _latestRewardToken = _rewardToken; - } - - if ( - _userLastClaimedTimestamp > 0 && - _rewardToken.timestamp > _userLastClaimedTimestamp - ) { - _claimRewards(_gauge, _rewardToken.token, _user, _stakeBalance, true); - } else { - break; - } - } + if (_rewards > 0) { + userTokenRewardBalances[_user][_rewardToken.token] += _rewards; + emit RewardsClaimed(_gauge, _rewardToken.token, _user, _rewards, _exchangeRate); } - return _latestRewardToken; + return _rewards; } /** - * @notice Claim user rewards for a given gauge. + * @notice Claim user rewards for a given gauge and token. * @param _gauge Address of the gauge to claim rewards for + * @param _rewardToken Reward token to claim rewards for * @param _user Address of the user to claim rewards for * @param _stakeBalance User stake balance */ function _claim( address _gauge, + RewardToken memory _rewardToken, address _user, uint256 _stakeBalance ) internal { - RewardToken memory _rewardToken = _claimPastRewards(_gauge, _user, _stakeBalance); - - if (address(_rewardToken.token) != address(0)) { - _claimRewards(_gauge, _rewardToken.token, _user, _stakeBalance, false); - } - - userLastClaimedTimestamp[_user] = block.timestamp; + _claimRewards(_gauge, _rewardToken, _user, _stakeBalance); + _setUserGaugeRewardTokenLastClaimedTimestamp(_user, _gauge, address(_rewardToken.token)); } /** - * @notice Push a new reward token into the `gaugeRewardTokens` array - * @param _gauge Address of the gauge to push reward token for - * @param _token Address of the reward token to push + * @notice Claim all user rewards for a given gauge. + * @dev Go through all the reward tokens for the given gauge and claim rewards. + * @param _gauge Address of the gauge to claim rewards for + * @param _user Address of the user to claim rewards for + * @param _stakeBalance User stake balance */ - function _pushRewardToken(address _gauge, IERC20 _token) internal { - uint256 _currentTimestamp = block.timestamp; + function _claimAll( + address _gauge, + address _user, + uint256 _stakeBalance + ) internal { + uint256 _gaugeRewardTokensLength = gaugeRewardTokens[_gauge].length; - gaugeRewardTokens[_gauge].push( - RewardToken({ token: _token, timestamp: uint64(_currentTimestamp) }) - ); + RewardToken memory _rewardToken; + + if (_gaugeRewardTokensLength > 0) { + uint256 i = _gaugeRewardTokensLength; - emit RewardTokenPushed(_gauge, _token, _currentTimestamp); + while (i > 0) { + i = i - 1; + _rewardToken = gaugeRewardTokens[_gauge][i]; + _claimRewards(_gauge, _rewardToken, _user, _stakeBalance); + _setUserGaugeRewardTokenLastClaimedTimestamp( + _user, + _gauge, + address(_rewardToken.token) + ); + } + } else { + // If no reward token has been added yet, set claimed timestamp for reward token 0 + _setUserGaugeRewardTokenLastClaimedTimestamp(_user, _gauge, address(0)); + } } /* ============ Modifiers ============ */ diff --git a/test/GaugeReward.test.ts b/test/GaugeReward.test.ts index e83069d8..2f26a47b 100644 --- a/test/GaugeReward.test.ts +++ b/test/GaugeReward.test.ts @@ -238,7 +238,7 @@ describe('GaugeReward', () => { expect(rewardToken.timestamp).to.equal(currentTimestamp); }); - it('should add rewards twice and return the first reward token', async () => { + it('should add rewards twice and return the only reward token', async () => { await afterSwap(poolToken, rewardsAmount, gaugeBalance); const firstSwapTimestamp = (await provider.getBlock('latest')).timestamp; @@ -274,21 +274,27 @@ describe('GaugeReward', () => { const currentTimestamp = (await provider.getBlock('latest')).timestamp; - expect(await gaugeReward.userLastClaimedTimestamp(owner.address)).to.equal( - currentTimestamp, - ); + expect( + await gaugeReward.userGaugeRewardTokenLastClaimedTimestamp( + owner.address, + gaugeAddress, + AddressZero, + ), + ).to.equal(currentTimestamp); const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); - const exchangeRate = await gaugeReward.tokenGaugeExchangeRates( - rewardToken.token, + const exchangeRate = await gaugeReward.gaugeRewardTokenExchangeRates( gaugeAddress, + rewardToken.token, + rewardToken.timestamp, ); expect( - await gaugeReward.userTokenGaugeExchangeRates( + await gaugeReward.userGaugeRewardTokenExchangeRates( owner.address, - rewardToken.token, gaugeAddress, + rewardToken.token, + rewardToken.timestamp, ), ).to.equal(exchangeRate); }); @@ -356,21 +362,27 @@ describe('GaugeReward', () => { const currentTimestamp = (await provider.getBlock('latest')).timestamp; - expect(await gaugeReward.userLastClaimedTimestamp(owner.address)).to.equal( - currentTimestamp, - ); + expect( + await await gaugeReward.userGaugeRewardTokenLastClaimedTimestamp( + owner.address, + gaugeAddress, + AddressZero, + ), + ).to.equal(currentTimestamp); const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); - const exchangeRate = await gaugeReward.tokenGaugeExchangeRates( - rewardToken.token, + const exchangeRate = await gaugeReward.gaugeRewardTokenExchangeRates( gaugeAddress, + rewardToken.token, + rewardToken.timestamp, ); expect( - await gaugeReward.userTokenGaugeExchangeRates( + await gaugeReward.userGaugeRewardTokenExchangeRates( owner.address, - rewardToken.token, gaugeAddress, + rewardToken.token, + rewardToken.timestamp, ), ).to.equal(exchangeRate); }); @@ -416,6 +428,175 @@ describe('GaugeReward', () => { }); }); + describe('getRewards()', () => { + let swapAmount: BigNumber; + let userStakeBalance: BigNumber; + let gaugeBalance: BigNumber; + + beforeEach(() => { + swapAmount = toWei('1000'); + userStakeBalance = toWei('100'); + gaugeBalance = toWei('100000'); + }); + + it('should return 0 if user has no stake', async () => { + await afterSwap(poolToken, swapAmount, gaugeBalance); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(Zero); + + const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + expect(await gaugeReward.getRewards(gaugeAddress, rewardToken, owner.address)).to.equal( + Zero, + ); + }); + + it('should return 0 if no reward token has been added', async () => { + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(userStakeBalance); + + const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + expect(await gaugeReward.getRewards(gaugeAddress, rewardToken, owner.address)).to.equal( + Zero, + ); + }); + + it('should return rewards for current and past reward token', async () => { + await gaugeController.call( + gaugeReward, + 'afterIncreaseGauge', + gaugeAddress, + owner.address, + userStakeBalance, + ); + + await afterSwap(poolToken, swapAmount, gaugeBalance); + await afterSwap(usdcToken, swapAmount, gaugeBalance); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(userStakeBalance); + + const previousRewardToken = await gaugeReward.gaugeRewardTokens(gaugeAddress, 0); + const currentRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + expect( + await gaugeReward.getRewards(gaugeAddress, previousRewardToken, owner.address), + ).to.equal(userRewardAmount(swapAmount, gaugeBalance, userStakeBalance)); + + expect( + await gaugeReward.getRewards(gaugeAddress, currentRewardToken, owner.address), + ).to.equal(userRewardAmount(swapAmount, gaugeBalance, userStakeBalance)); + }); + + it('should return 0 if not eligible to past rewards', async () => { + await afterSwap(poolToken, swapAmount, gaugeBalance); + + await gaugeController.call( + gaugeReward, + 'afterIncreaseGauge', + gaugeAddress, + owner.address, + userStakeBalance, + ); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(userStakeBalance); + + const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + expect(await gaugeReward.getRewards(gaugeAddress, rewardToken, owner.address)).to.equal( + Zero, + ); + }); + + it('should return 0 if trying to claim for a reward token that does not exist', async () => { + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(Zero); + + const claimTimestamp = (await provider.getBlock('latest')).timestamp; + + await gaugeReward.claim( + gaugeAddress, + { token: poolToken.address, timestamp: claimTimestamp }, + owner.address, + ); + + await afterSwap(poolToken, swapAmount, gaugeBalance); + + await gaugeController.call( + gaugeReward, + 'afterIncreaseGauge', + gaugeAddress, + owner.address, + userStakeBalance, + ); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(userStakeBalance); + + expect( + await gaugeReward.getRewards( + gaugeAddress, + { + token: poolToken.address, + timestamp: claimTimestamp, + }, + owner.address, + ), + ).to.equal(Zero); + }); + + it('should return 0 if trying to claim for a previous reward token when at the time user did not have any stake', async () => { + await afterSwap(poolToken, swapAmount, gaugeBalance); + + const firstPoolRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(Zero); + + await gaugeController.call( + gaugeReward, + 'afterIncreaseGauge', + gaugeAddress, + owner.address, + userStakeBalance, + ); + + await afterSwap(usdcToken, swapAmount, gaugeBalance); + + const usdcRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + await afterSwap(poolToken, swapAmount, gaugeBalance); + + const lastPoolRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + await gaugeController.mock.getUserGaugeBalance + .withArgs(gaugeAddress, owner.address) + .returns(userStakeBalance); + + expect( + await gaugeReward.getRewards(gaugeAddress, firstPoolRewardToken, owner.address), + ).to.equal(Zero); + + expect( + await gaugeReward.getRewards(gaugeAddress, usdcRewardToken, owner.address), + ).to.equal(userRewardAmount(swapAmount, gaugeBalance, userStakeBalance)); + + expect( + await gaugeReward.getRewards(gaugeAddress, lastPoolRewardToken, owner.address), + ).to.equal(userRewardAmount(swapAmount, gaugeBalance, userStakeBalance)); + }); + }); + describe('claim()', () => { let swapAmount: BigNumber; let userStakeBalance: BigNumber; @@ -444,12 +625,14 @@ describe('GaugeReward', () => { .withArgs(gaugeAddress, owner.address) .returns(userStakeBalance); + const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + // Alice claims her share of rewards earned from the swap - expect(await gaugeReward.claim(gaugeAddress, owner.address)) + expect(await gaugeReward.claim(gaugeAddress, rewardToken, owner.address)) .to.emit(gaugeReward, 'RewardsClaimed') .withArgs( gaugeAddress, - poolToken.address, + rewardToken.token, owner.address, userRewardAmount(swapAmount, gaugeBalance, userStakeBalance), exchangeRate(swapAmount, gaugeBalance), @@ -466,29 +649,32 @@ describe('GaugeReward', () => { ); await afterSwap(poolToken, swapAmount, gaugeBalance); + + const previousRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + await afterSwap(usdcToken, swapAmount, gaugeBalance); + const currentRewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + await gaugeController.mock.getUserGaugeBalance .withArgs(gaugeAddress, owner.address) .returns(userStakeBalance); - const claimTx = await gaugeReward.claim(gaugeAddress, owner.address); - - expect(claimTx) + await expect(gaugeReward.claim(gaugeAddress, previousRewardToken, owner.address)) .to.emit(gaugeReward, 'RewardsClaimed') .withArgs( gaugeAddress, - poolToken.address, + previousRewardToken.token, owner.address, userRewardAmount(swapAmount, gaugeBalance, userStakeBalance), exchangeRate(swapAmount, gaugeBalance), ); - expect(claimTx) + await expect(gaugeReward.claim(gaugeAddress, currentRewardToken, owner.address)) .to.emit(gaugeReward, 'RewardsClaimed') .withArgs( gaugeAddress, - usdcToken.address, + currentRewardToken.token, owner.address, userRewardAmount(swapAmount, gaugeBalance, userStakeBalance), exchangeRate(swapAmount, gaugeBalance), @@ -510,7 +696,7 @@ describe('GaugeReward', () => { .withArgs(gaugeAddress, owner.address) .returns(userStakeBalance); - expect(await gaugeReward.claim(gaugeAddress, owner.address)) + expect(await gaugeReward.claimAll(gaugeAddress, owner.address)) .to.not.emit(gaugeReward, 'RewardsClaimed') .withArgs( gaugeAddress, @@ -548,17 +734,18 @@ describe('GaugeReward', () => { .withArgs(gaugeAddress, owner.address) .returns(userStakeBalance); - await gaugeReward.claim(gaugeAddress, owner.address); + const rewardToken = await gaugeReward.currentRewardToken(gaugeAddress); + + await gaugeReward.claim(gaugeAddress, rewardToken, owner.address); - const rewardToken = (await gaugeReward.currentRewardToken(gaugeAddress)).token; const gaugeRewardAmount = await gaugeReward.userTokenRewardBalances( owner.address, - rewardToken, + rewardToken.token, ); - expect(await gaugeReward.redeem(owner.address, rewardToken)) + expect(await gaugeReward.redeem(owner.address, rewardToken.token)) .to.emit(gaugeReward, 'RewardsRedeemed') - .withArgs(owner.address, owner.address, rewardToken, gaugeRewardAmount); + .withArgs(owner.address, owner.address, rewardToken.token, gaugeRewardAmount); }); }); });