rescue funds

Author: aalavandhan

contracts/TokenGeyser.sol

@@ -35,7 +35,7 @@ contract TokenGeyser is IStaking, Ownable {
     // amount: Unlocked tokens, total: Total locked tokens
     event TokensUnlocked(uint256 amount, uint256 total);
 
-    TokenPool private _stakingPool;
+    TokenPool public stakingPool;
     TokenPool private _unlockedPool;
     TokenPool private _lockedPool;
 
@@ -110,7 +110,7 @@ contract TokenGeyser is IStaking, Ownable {
         require(bonusPeriodSec_ != 0, 'TokenGeyser: bonus period is zero');
         require(initialSharesPerToken > 0, 'TokenGeyser: initialSharesPerToken is zero');
 
-        _stakingPool = new TokenPool(stakingToken);
+        stakingPool = new TokenPool(stakingToken);
         _unlockedPool = new TokenPool(distributionToken);
         _lockedPool = new TokenPool(distributionToken);
         startBonus = startBonus_;
@@ -123,7 +123,7 @@ contract TokenGeyser is IStaking, Ownable {
      * @return The token users deposit as stake.
      */
     function getStakingToken() public view returns (IERC20) {
-        return _stakingPool.token();
+        return stakingPool.token();
     }
 
     /**
@@ -186,7 +186,7 @@ contract TokenGeyser is IStaking, Ownable {
         // _lastAccountingTimestampSec = now;
 
         // interactions
-        require(_stakingPool.token().transferFrom(staker, address(_stakingPool), amount),
+        require(stakingPool.token().transferFrom(staker, address(stakingPool), amount),
             'TokenGeyser: transfer into staking pool failed');
 
         emit Staked(beneficiary, amount, totalStakedFor(beneficiary), "");
@@ -266,7 +266,7 @@ contract TokenGeyser is IStaking, Ownable {
         // _lastAccountingTimestampSec = now;
 
         // interactions
-        require(_stakingPool.transfer(msg.sender, amount),
+        require(stakingPool.transfer(msg.sender, amount),
             'TokenGeyser: transfer out of staking pool failed');
         require(_unlockedPool.transfer(msg.sender, rewardAmount),
             'TokenGeyser: transfer out of unlocked pool failed');
@@ -328,7 +328,7 @@ contract TokenGeyser is IStaking, Ownable {
      * @return The total number of deposit tokens staked globally, by all users.
      */
     function totalStaked() public view returns (uint256) {
-        return _stakingPool.balance();
+        return stakingPool.balance();
     }
 
     /**
@@ -500,4 +500,13 @@ contract TokenGeyser is IStaking, Ownable {
         schedule.unlockedShares = schedule.unlockedShares.add(sharesToUnlock);
         return sharesToUnlock;
     }
+
+    /**
+     * @dev Lets the owner rescue funds air-dropped to the staking pool.
+     */
+    function rescueFundsFromStakingPool(address _tokenToRescue, address to, uint256 amount)
+        public onlyOwner returns (bool) {
+
+        return stakingPool.rescueFunds(_tokenToRescue, to, amount);
+    }
 }

contracts/TokenPool.sol

@@ -22,4 +22,10 @@ contract TokenPool is Ownable {
     function transfer(address to, uint256 value) external onlyOwner returns (bool) {
         return token.transfer(to, value);
     }
+
+    function rescueFunds(address _tokenToRescue, address to, uint256 amount) external onlyOwner returns (bool) {
+        require(address(token) != _tokenToRescue, 'TokenPool: Cannot claim token held by the contract');
+
+        return IERC20(_tokenToRescue).transfer(to, amount);
+    }
 }

contracts/mocks/MockErc20.sol

@@ -0,0 +1,7 @@
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    constructor(uint256 _totalSupply) public {
+        _mint(msg.sender, _totalSupply);
+    }
+}

test/staking.js

@@ -10,6 +10,7 @@ const {
   invokeRebase
 } = _require('/test/helper');
 
+const MockERC20 = contract.fromArtifact('MockERC20');
 const AmpleforthErc20 = contract.fromArtifact('UFragments');
 const TokenGeyser = contract.fromArtifact('TokenGeyser');
 const InitialSharesPerToken = 10 ** 6;
@@ -218,3 +219,42 @@ describe('staking', function () {
     });
   });
 });
+
+
+describe('rescueFundsFromStakingPool', function () {
+  describe('when tokens gets air-dropped', function() {
+    it('should allow the owner to claim them', async function() {
+      const accounts = await chain.getUserAccounts();
+      owner = web3.utils.toChecksumAddress(accounts[0]);
+      anotherAccount = web3.utils.toChecksumAddress(accounts[8]);
+
+      ampl = await AmpleforthErc20.new();
+      await ampl.initialize(owner);
+      await ampl.setMonetaryPolicy(owner);
+
+      const startBonus = 50;
+      const bonusPeriod = 86400;
+      const dist = await TokenGeyser.new(ampl.address, ampl.address, 10, startBonus, bonusPeriod,
+        InitialSharesPerToken);
+
+      const stakingPool = await dist.stakingPool.call();
+
+      await ampl.approve(dist.address, $AMPL(100));
+      await dist.stake($AMPL(100), []);
+
+      const token = await MockERC20.new(1000);
+      await token.transfer(stakingPool, 1000);
+
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+      await dist.rescueFundsFromStakingPool(
+        token.address, anotherAccount, 1000
+      );
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('1000');
+
+      await expectRevert(
+        dist.rescueFundsFromStakingPool(ampl.address, anotherAccount, $AMPL(10)),
+        'TokenPool: Cannot claim token held by the contract'
+      );
+    })
+  });
+});

test/token_pool.js

@@ -0,0 +1,108 @@
+const { contract, web3 } = require('@openzeppelin/test-environment');
+const { expectRevert, expectEvent } = require('@openzeppelin/test-helpers');
+const { expect } = require('chai');
+
+const _require = require('app-root-path').require;
+const BlockchainCaller = _require('/util/blockchain_caller');
+const chain = new BlockchainCaller(web3);
+
+const MockERC20 = contract.fromArtifact('MockERC20');
+const TokenPool = contract.fromArtifact('TokenPool');
+
+let token, otherToken, tokenPool, owner, anotherAccount;
+describe('tokenPool', function () {
+  beforeEach('setup contracts', async function () {
+    const accounts = await chain.getUserAccounts();
+    owner = web3.utils.toChecksumAddress(accounts[0]);
+    anotherAccount = web3.utils.toChecksumAddress(accounts[8]);
+
+    token = await MockERC20.new(1000);
+    otherToken = await MockERC20.new(2000);
+
+    tokenPool = await TokenPool.new(token.address);
+  });
+
+  describe('balance', function() {
+    it('should return the balance of the token pool', async function(){
+      await token.transfer(tokenPool.address, 123);
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('123');
+      await tokenPool.transfer(owner, 99);
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('24');
+      await tokenPool.transfer(owner, 24);
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('0');
+    });
+  });
+
+  describe('transfer', function() {
+    it('should let the owner transfer funds out', async function(){
+      await token.transfer(tokenPool.address, 1000);
+
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('1000');
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+
+      await tokenPool.transfer(anotherAccount, 1000);
+
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('0');
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('1000');
+    });
+
+    it('should NOT let other users transfer funds out', async function(){
+      await token.transfer(tokenPool.address, 1000);
+      await expectRevert(
+        tokenPool.transfer(anotherAccount, 1000, { from: anotherAccount }),
+        'Ownable: caller is not the owner'
+      );
+    });
+  });
+
+  describe('rescueFunds', function() {
+    beforeEach(async function(){
+      await token.transfer(tokenPool.address, 1000);
+      await otherToken.transfer(tokenPool.address, 2000);
+
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('1000');
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+      expect(await otherToken.balanceOf.call(tokenPool.address)).to.be.bignumber.equal('2000');
+      expect(await otherToken.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+    });
+
+    it('should let owner users claim excess funds completely', async function(){
+      await tokenPool.rescueFunds(otherToken.address, anotherAccount, 2000);
+
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('1000');
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+      expect(await otherToken.balanceOf.call(tokenPool.address)).to.be.bignumber.equal('0');
+      expect(await otherToken.balanceOf.call(anotherAccount)).to.be.bignumber.equal('2000');
+    });
+
+    it('should let owner users claim excess funds partially', async function(){
+      await tokenPool.rescueFunds(otherToken.address, anotherAccount, 777);
+
+      expect(await tokenPool.balance.call()).to.be.bignumber.equal('1000');
+      expect(await token.balanceOf.call(anotherAccount)).to.be.bignumber.equal('0');
+      expect(await otherToken.balanceOf.call(tokenPool.address)).to.be.bignumber.equal('1223');
+      expect(await otherToken.balanceOf.call(anotherAccount)).to.be.bignumber.equal('777');
+    });
+
+    it('should NOT let owner claim more than available excess funds', async function(){
+      await expectRevert(
+        tokenPool.rescueFunds(otherToken.address, anotherAccount, 2001),
+        'ERC20: transfer amount exceeds balance'
+      );
+    });
+
+    it('should NOT let owner users claim held funds', async function(){
+      await expectRevert(
+        tokenPool.rescueFunds(token.address, anotherAccount, 1000),
+        'TokenPool: Cannot claim token held by the contract'
+      );
+    });
+
+    it('should NOT let other users users claim excess funds', async function(){
+      await expectRevert(
+        tokenPool.rescueFunds(otherToken.address, anotherAccount, 2000, { from: anotherAccount }),
+        'Ownable: caller is not the owner'
+      );
+    });
+  });
+});