Merge pull request #108 from gammaswap/feat/emit-error-lpviewer

publish package
gammaswap · May 4, 2024 · 634acc9 · 634acc9
2 parents fa947f4 + ec5150d
commit 634acc9
Show file tree

Hide file tree

Showing 4 changed files with 165 additions and 19 deletions.
diff --git a/contracts/lens/LPViewer.sol b/contracts/lens/LPViewer.sol
@@ -16,7 +16,7 @@ contract LPViewer is ILPViewer, TwoStepOwnable {
     mapping(address => uint256) tokenIndex;
     mapping(address => address[]) public stakingPoolsByPool;
 
-    constructor() TwoStepOwnable(msg.sender) {
+    constructor(address _owner) TwoStepOwnable(_owner) {
     }
 
     /// @dev Find index of rewardTracker (staking contract) of a given pool in array value of stakingPoolsByPool
@@ -39,23 +39,22 @@ contract LPViewer is ILPViewer, TwoStepOwnable {
 
     /// @inheritdoc ILPViewer
     function registerRewardTracker(address pool, address rewardTracker) public override virtual onlyOwner {
-        int256 idx = findRewardTracker(pool, rewardTracker);
-        if(idx == -1) {
-            if(RewardTracker(rewardTracker).isDepositToken(pool)) {
-                stakingPoolsByPool[pool].push(rewardTracker);
+        require(RewardTracker(rewardTracker).isDepositToken(pool), "LP_VIEWER: RT_NOT_DEPOSIT_TOKEN");
+        require(findRewardTracker(pool, rewardTracker) == -1, "LP_VIEWER: RT_REGISTERED");
 
-                emit RegisterRewardTracker(pool, rewardTracker);
-            }
-        }
+        stakingPoolsByPool[pool].push(rewardTracker);
+
+        emit RegisterRewardTracker(pool, rewardTracker);
     }
 
     /// @inheritdoc ILPViewer
     function unregisterRewardTracker(address pool, address rewardTracker) public override virtual onlyOwner {
         int256 idx = findRewardTracker(pool, rewardTracker);
-        if(idx >= 0) {
-            stakingPoolsByPool[pool][uint256(idx)] = address(0);
-            emit UnregisterRewardTracker(pool, rewardTracker);
-        }
+        require(idx >= 0, "LP_VIEWER: RT_NOT_REGISTERED");
+
+        stakingPoolsByPool[pool][uint256(idx)] = address(0);
+
+        emit UnregisterRewardTracker(pool, rewardTracker);
     }
 
     /// @inheritdoc ILPViewer

diff --git a/contracts/test/TestRewardTracker.sol b/contracts/test/TestRewardTracker.sol
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import "@gammaswap/v1-staking/contracts/RewardTracker.sol";
+
+contract TestRewardTracker is RewardTracker {
+
+    constructor(string memory _name, string memory _symbol) RewardTracker(_name, _symbol) {
+    }
+
+    function _stake(address _fundingAccount, address _account, address _depositToken, uint256 _amount) internal virtual override {
+        require(_amount > 0, "RewardTracker: invalid _amount");
+        require(isDepositToken[_depositToken], "RewardTracker: invalid _depositToken");
+
+        IERC20(_depositToken).transferFrom(_fundingAccount, address(this), _amount);
+
+        //_updateRewards(_account);
+
+        stakedAmounts[_account] = stakedAmounts[_account] + _amount;
+        depositBalances[_account][_depositToken] = depositBalances[_account][_depositToken] + _amount;
+        totalDepositSupply[_depositToken] = totalDepositSupply[_depositToken] + _amount;
+
+        _mint(_account, _amount);
+
+        emit Stake(_fundingAccount, _account, _depositToken, _amount);
+    }
+
+    function _unstake(address _account, address _depositToken, uint256 _amount, address _receiver) internal virtual override {
+        require(_amount > 0, "RewardTracker: invalid _amount");
+
+        //_updateRewards(_account);
+
+        uint256 stakedAmount = stakedAmounts[_account];
+        require(stakedAmount >= _amount, "RewardTracker: _amount exceeds stakedAmount");
+
+        stakedAmounts[_account] = stakedAmount - _amount;
+
+        uint256 depositBalance = depositBalances[_account][_depositToken];
+        require(depositBalance >= _amount, "RewardTracker: _amount exceeds depositBalance");
+
+        depositBalances[_account][_depositToken] = depositBalance - _amount;
+        totalDepositSupply[_depositToken] = totalDepositSupply[_depositToken] - _amount;
+
+        _burn(_account, _amount);
+        IERC20(_depositToken).transfer(_receiver, _amount);
+
+        emit Unstake(_account, _depositToken, _amount, _receiver);
+    }
+}
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@gammaswap/v1-periphery",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "description": "Periphery contracts for the GammaSwap V1 protocol",
   "homepage": "https://gammaswap.com",
   "scripts": {

diff --git a/test/foundry/LPViewer.t.sol b/test/foundry/LPViewer.t.sol
@@ -3,6 +3,7 @@ pragma solidity ^0.8.0;
 import "forge-std/Test.sol";
 import "../../contracts/test/TestGammaPool3.sol";
 import "../../contracts/lens/LPViewer.sol";
+import "../../contracts/test/TestRewardTracker.sol";
 
 contract LPViewerTest is Test {
 
@@ -23,9 +24,18 @@ contract LPViewerTest is Test {
     address addr4;
 
     LPViewer lpViewer;
+    RewardTracker rewardTracker1;
+    RewardTracker rewardTracker2;
 
     function setUp() public {
-        lpViewer = new LPViewer();
+        addr1 = vm.addr(1);
+        addr2 = vm.addr(2);
+        addr3 = vm.addr(3);
+        addr4 = vm.addr(4);
+
+        lpViewer = new LPViewer(addr1);
+        rewardTracker1 = new TestRewardTracker("Reward Tracker 1", "RT1");
+        rewardTracker2 = new TestRewardTracker("Reward Tracker 2", "RT2");
         tokenA = new TERC20("TokenA", "TOKA");
         tokenB = new TERC20("TokenB", "TOKB");
         tokenC = new TERC20("TokenC", "TOKC");
@@ -37,11 +47,6 @@ contract LPViewerTest is Test {
         pool3 = createPool(4, address(tokenB), address(tokenD));
         pool4 = createPool(5, address(tokenA), address(tokenE));
 
-        addr1 = vm.addr(1);
-        addr2 = vm.addr(2);
-        addr3 = vm.addr(3);
-        addr4 = vm.addr(4);
-
         pool0.mintTo(addr1, 100*1e18);
         pool1.mintTo(addr1, 200*1e18);
         pool2.mintTo(addr1, 300*1e18);
@@ -65,6 +70,99 @@ contract LPViewerTest is Test {
         pool.initialize(address(666), tokens, decimals, 0, "0x");
     }
 
+    function testRegisterRewardTracker() public {
+        vm.prank(address(this));
+        rewardTracker1.setDepositToken(address(pool0), true);
+
+        vm.expectRevert("Forbidden");
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.startPrank(addr1);
+
+        vm.expectRevert();
+        lpViewer.registerRewardTracker(address(pool0), address(pool1));
+
+        vm.expectRevert("LP_VIEWER: RT_NOT_DEPOSIT_TOKEN");
+        lpViewer.registerRewardTracker(address(pool1), address(rewardTracker1));
+
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.expectRevert("LP_VIEWER: RT_REGISTERED");
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.stopPrank();
+    }
+
+    function testUnregisterRewardTracker() public {
+        vm.prank(address(this));
+        rewardTracker1.setDepositToken(address(pool0), true);
+
+        vm.expectRevert("Forbidden");
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.startPrank(addr1);
+
+        vm.expectRevert("LP_VIEWER: RT_NOT_REGISTERED");
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker1));
+
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.expectRevert("LP_VIEWER: RT_NOT_REGISTERED");
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker2));
+
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.expectRevert("LP_VIEWER: RT_NOT_REGISTERED");
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker1));
+
+        vm.stopPrank();
+    }
+
+    function testStakedLPBalance() public {
+        vm.startPrank(address(this));
+        rewardTracker1.setDepositToken(address(pool0), true);
+        rewardTracker1.setInPrivateStakingMode(false);
+
+        rewardTracker2.setDepositToken(address(pool0), true);
+        rewardTracker2.setInPrivateStakingMode(false);
+        vm.stopPrank();
+
+        vm.startPrank(addr1);
+
+        pool0.approve(address(rewardTracker1), type(uint256).max);
+        pool0.approve(address(rewardTracker2), type(uint256).max);
+
+        rewardTracker1.stake(address(pool0), 1e18);
+
+        assertEq(1e18,rewardTracker1.stakedAmounts(addr1));
+        assertEq(0,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker1));
+
+        assertEq(1e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        rewardTracker2.stake(address(pool0), 2e18);
+
+        assertEq(1e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        lpViewer.registerRewardTracker(address(pool0), address(rewardTracker2));
+        assertEq(3e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        lpViewer.unregisterRewardTracker(address(pool0), address(rewardTracker1));
+        assertEq(2e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        rewardTracker1.unstake(address(pool0), 1e18);
+        assertEq(2e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        rewardTracker2.unstake(address(pool0), 1e18);
+        assertEq(1e18,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        rewardTracker2.unstake(address(pool0), 1e18);
+        assertEq(0,lpViewer.getStakedLPBalance(addr1, address(pool0)));
+
+        vm.stopPrank();
+    }
+
     function testTotalSupplies() public {
         assertEq(pool0.totalSupply(),200 * 1e18);
         assertEq(pool1.totalSupply(),400 * 1e18);