Merge pull request #6 from ampleforth/rescue-funds

Author: aalavandhan

contracts/TokenGeyser.sol

@@ -500,4 +500,17 @@ 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.
+     * @param tokenToRescue Address of the token to be rescued.
+     * @param to Address to which the rescued funds are to be sent.
+     * @param amount Amount of tokens to be rescued.
+     * @return Transfer success.
+     */
+    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,48 @@ 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);
+
+      await ampl.approve(dist.address, $AMPL(100));
+      await dist.stake($AMPL(100), []);
+
+      const transfers = await ampl.contract.getPastEvents('Transfer');
+      const transferLog = transfers[transfers.length - 1];
+      const stakingPool = transferLog.returnValues.to;
+
+      expect(await ampl.balanceOf.call(stakingPool)).to.be.bignumber.equal($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'
+      );
+
+      expect(await ampl.balanceOf.call(stakingPool)).to.be.bignumber.equal($AMPL(100));
+    })
+  });
+});

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'
+      );
+    });
+  });
+});