Merge pull request #138 from Instadapp/feat/quickswap-fix

updated sushi-incentive connector

contracts/mainnet/connectors/sushi-incentive/events.sol

@@ -1,28 +1,39 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.0;
 
 contract Events {
 	event LogDeposit(
+		address token1,
+		address token2,
 		uint256 indexed pid,
 		uint256 indexed version,
 		uint256 amount
 	);
 	event LogWithdraw(
+		address token1,
+		address token2,
 		uint256 indexed pid,
 		uint256 indexed version,
 		uint256 amount
 	);
 	event LogEmergencyWithdraw(
+		address token1,
+		address token2,
 		uint256 indexed pid,
 		uint256 indexed version,
 		uint256 lpAmount,
 		uint256 rewardsAmount
 	);
 	event LogHarvest(
+		address token1,
+		address token2,
 		uint256 indexed pid,
 		uint256 indexed version,
 		uint256 amount
 	);
 	event LogWithdrawAndHarvest(
+		address token1,
+		address token2,
 		uint256 indexed pid,
 		uint256 indexed version,
 		uint256 widrawAmount,

contracts/mainnet/connectors/sushi-incentive/helpers.sol

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity ^0.7.0;
 pragma experimental ABIEncoderV2;
 
@@ -15,74 +14,93 @@ contract Helpers is DSMath, Basic {
 	ISushiSwapFactory immutable factory =
 		ISushiSwapFactory(0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac);
 
-    function _deposit(uint256 _pid, uint256 _amount, uint256 _version) internal {
+	struct Metadata {
-        if(_version == 2)
+		uint256 poolId;
-            masterChefV2.deposit(_pid, _amount, address(this));
+		uint256 version;
-        else
+		address lpToken;
-            masterChef.deposit(_pid, _amount);
 	}
 
-    function _withdraw(uint256 _pid, uint256 _amount, uint256 _version) internal {
+	function _deposit(Metadata memory data, uint256 _amount) internal {
-        if(_version == 2)
+		if (data.version == 2)
-            masterChefV2.withdraw(_pid, _amount, address(this));
+			masterChefV2.deposit(data.poolId, _amount, address(this));
-        else
+		else masterChef.deposit(data.poolId, _amount);
-            masterChef.withdraw(_pid, _amount);
 	}
 
-    function _harvest(uint256 _pid) internal {
+	function _withdraw(Metadata memory data, uint256 _amount) internal {
-        masterChefV2.harvest(_pid, address(this));
+		if (data.version == 2)
+			masterChefV2.withdraw(data.poolId, _amount, address(this));
+		else masterChef.withdraw(data.poolId, _amount);
 	}
 
-    function _withdrawAndHarvest(uint256 _pid, uint256 _amount, uint256 _version) internal {
+	function _harvest(Metadata memory data) internal {
-        if(_version == 2)
+		masterChefV2.harvest(data.poolId, address(this));
-            masterChefV2.withdrawAndHarvest(_pid, _amount, address(this));
-        else _withdraw(_pid, _amount, _version);
 	}
 
-    function _emergencyWithdraw(uint256 _pid, uint256 _version) internal {
+	function _withdrawAndHarvest(Metadata memory data, uint256 _amount)
-        if(_version == 2)
+		internal
-            masterChefV2.emergencyWithdraw(_pid, address(this));
+	{
-        else 
+		if (data.version == 2)
-            masterChef.emergencyWithdraw(_pid, address(this));
+			masterChefV2.withdrawAndHarvest(
+				data.poolId,
+				_amount,
+				address(this)
+			);
+		else _withdraw(data, _amount);
+	}
+
+	function _emergencyWithdraw(Metadata memory data) internal {
+		if (data.version == 2)
+			masterChefV2.emergencyWithdraw(data.poolId, address(this));
+		else masterChef.emergencyWithdraw(data.poolId, address(this));
 	}
 
 	function _getPoolId(address tokenA, address tokenB)
 		internal
 		view
-        returns (uint256 poolId, uint256 version, address lpToken)
+		returns (Metadata memory data)
 	{
 		address pair = factory.getPair(tokenA, tokenB);
 		uint256 length = masterChefV2.poolLength();
-        version = 2;
+		data.version = 2;
-        poolId = uint256(-1);
+		data.poolId = uint256(-1);
 
 		for (uint256 i = 0; i < length; i++) {
-            lpToken = masterChefV2.lpToken(i);
+			data.lpToken = masterChefV2.lpToken(i);
-            if (pair == lpToken) {
+			if (pair == data.lpToken) {
-                poolId = i;
+				data.poolId = i;
 				break;
 			}
 		}
 
 		uint256 lengthV1 = masterChef.poolLength();
 		for (uint256 i = 0; i < lengthV1; i++) {
-            (lpToken, , , ) = masterChef.poolInfo(i);
+			(data.lpToken, , , ) = masterChef.poolInfo(i);
-            if (pair == lpToken) {
+			if (pair == data.lpToken) {
-                poolId = i;
+				data.poolId = i;
-                version = 1;
+				data.version = 1;
 				break;
 			}
 		}
 	}
 
-    function _getUserInfo(uint256 _pid, uint256 _version)
+	function _getUserInfo(Metadata memory data)
 		internal
 		view
 		returns (uint256 lpAmount, uint256 rewardsAmount)
 	{
-        if(_version == 2)
+		if (data.version == 2)
-            (lpAmount, rewardsAmount) = masterChefV2.userInfo(_pid, address(this));
+			(lpAmount, rewardsAmount) = masterChefV2.userInfo(
+				data.poolId,
+				address(this)
+			);
 		else
-            (lpAmount, rewardsAmount) = masterChef.userInfo(_pid, address(this));
+			(lpAmount, rewardsAmount) = masterChef.userInfo(
+				data.poolId,
+				address(this)
+			);
+	}
+
+	function _balance(address token1, address token2) internal view returns (uint balance) {
+		balance = IERC20(token1).balanceOf(address(this)) + IERC20(token2).balanceOf(address(this));
 	}
 }

contracts/mainnet/connectors/sushi-incentive/interface.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.0;
 pragma experimental ABIEncoderV2;
 
@@ -18,12 +19,19 @@ interface IERC20 {
 
 	function balanceOf(address account) external view returns (uint256);
 
-    function allowance(address owner, address spender) external view returns (uint256);
+	function allowance(address owner, address spender)
+		external
+		view
+		returns (uint256);
 
 	function approve(address spender, uint256 amount) external returns (bool);
 
 	event Transfer(address indexed from, address indexed to, uint256 value);
-    event Approval(address indexed owner, address indexed spender, uint256 value);
+	event Approval(
+		address indexed owner,
+		address indexed spender,
+		uint256 value
+	);
 
 	/// @notice EIP 2612
 	function permit(
@@ -42,22 +50,24 @@ interface IMasterChef {
 
 	function updatePool(uint256 pid) external returns (PoolInfo memory);
 
-    function poolInfo(uint256 pid) external view returns (address, uint256, uint256, uint256);
+	function poolInfo(uint256 pid)
+		external
+		view
+		returns (
+			address,
+			uint256,
+			uint256,
+			uint256
+		);
 
 	function userInfo(uint256 _pid, address _user)
 		external
 		view
 		returns (uint256, uint256);
 
-    function deposit(
+	function deposit(uint256 pid, uint256 amount) external;
-        uint256 pid,
-        uint256 amount
-    ) external;
 
-    function withdraw(
+	function withdraw(uint256 pid, uint256 amount) external;
-        uint256 pid,
-        uint256 amount
-    ) external;
 
 	function emergencyWithdraw(uint256 pid, address to) external;
 }

contracts/mainnet/connectors/sushi-incentive/main.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.0;
 pragma experimental ABIEncoderV2;
 
@@ -25,7 +26,8 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		address token2,
 		uint256 amount,
 		uint256 getId,
-        uint256 setId
+		uint256 setId,
+		Metadata memory data
 	)
 		external
 		payable
@@ -34,17 +36,26 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		token1 = changeEthAddrToWethAddr(token1);
 		token2 = changeEthAddrToWethAddr(token2);
 		amount = getUint(getId, amount);
-        (uint256 _pid, uint256 _version, address lpTokenAddr) = _getPoolId(
+		if (
-            token1,
+			data.poolId == uint256(-1) ||
-            token2
+			data.version == 0 ||
-        );
+			data.lpToken == address(0)
-        setUint(setId, _pid);
+		) {
-        require(_pid != uint256(-1), "pool-does-not-exist");
+			data = _getPoolId(token1, token2);
-        TokenInterface lpToken = TokenInterface(lpTokenAddr);
+		}
+		setUint(setId, data.poolId);
+		require(data.poolId != uint256(-1), "pool-does-not-exist");
+		TokenInterface lpToken = TokenInterface(data.lpToken);
 		lpToken.approve(address(masterChef), amount);
-        _deposit(_pid, amount, _version);
+		_deposit(data, amount);
-        _eventName = "LogDeposit(uint256,uint256,uint256)";
+		_eventName = "LogDeposit(address,address,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_pid, _version, amount);
+		_eventParam = abi.encode(
+			token1,
+			token2,
+			data.poolId,
+			data.version,
+			amount
+		);
 	}
 
 	/**
@@ -61,7 +72,8 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		address token2,
 		uint256 amount,
 		uint256 getId,
-        uint256 setId
+		uint256 setId,
+		Metadata memory data
 	)
 		external
 		payable
@@ -70,12 +82,20 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		token1 = changeEthAddrToWethAddr(token1);
 		token2 = changeEthAddrToWethAddr(token2);
 		amount = getUint(getId, amount);
-        (uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
+		if (data.poolId == uint256(-1) || data.version == 0) {
-        setUint(setId, _pid);
+			data = _getPoolId(token1, token2);
-        require(_pid != uint256(-1), "pool-does-not-exist");
+		}
-        _withdraw(_pid, amount, _version);
+		setUint(setId, amount);
-        _eventName = "LogWithdraw(uint256,uint256,uint256)";
+		require(data.poolId != uint256(-1), "pool-does-not-exist");
-        _eventParam = abi.encode(_pid, _version, amount);
+		_withdraw(data, amount);
+		_eventName = "LogDeposit(address,address,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			token1,
+			token2,
+			data.poolId,
+			data.version,
+			amount
+		);
 	}
 
 	/**
@@ -88,7 +108,8 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 	function harvest(
 		address token1,
 		address token2,
-        uint256 setId
+		uint256 setId,
+		Metadata memory data
 	)
 		external
 		payable
@@ -96,14 +117,22 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 	{
 		token1 = changeEthAddrToWethAddr(token1);
 		token2 = changeEthAddrToWethAddr(token2);
-        (uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
+		if (data.poolId == uint256(-1) || data.version == 0) {
-        setUint(setId, _pid);
+			data = _getPoolId(token1, token2);
-        require(_pid != uint256(-1), "pool-does-not-exist");
+		}
-        (, uint256 rewardsAmount) = _getUserInfo(_pid, _version);
+		setUint(setId, data.poolId);
-        if (_version == 2) _harvest(_pid);
+		require(data.poolId != uint256(-1), "pool-does-not-exist");
-        else _withdraw(_pid, 0, _version);
+		(, uint256 rewardsAmount) = _getUserInfo(data);
-        _eventName = "LogHarvest(uint256,uint256,uint256)";
+		if (data.version == 2) _harvest(data);
-        _eventParam = abi.encode(_pid, _version, rewardsAmount);
+		else _withdraw(data, 0);
+		_eventName = "LogDeposit(address,address,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			token1,
+			token2,
+			data.poolId,
+			data.version,
+			rewardsAmount
+		);
 	}
 
 	/**
@@ -120,7 +149,8 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		address token2,
 		uint256 amount,
 		uint256 getId,
-        uint256 setId
+		uint256 setId,
+		Metadata memory data
 	)
 		external
 		payable
@@ -129,13 +159,22 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 		token1 = changeEthAddrToWethAddr(token1);
 		token2 = changeEthAddrToWethAddr(token2);
 		amount = getUint(getId, amount);
-        (uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
+		if (data.poolId == uint256(-1) || data.version == 0) {
-        setUint(setId, _pid);
+			data = _getPoolId(token1, token2);
-        require(_pid != uint256(-1), "pool-does-not-exist");
+		}
-        (, uint256 rewardsAmount) = _getUserInfo(_pid, _version);
+		setUint(setId, data.poolId);
-        _withdrawAndHarvest(_pid, amount, _version);
+		require(data.poolId != uint256(-1), "pool-does-not-exist");
-        _eventName = "LogWithdrawAndHarvest(uint256,uint256,uint256,uint256)";
+		(, uint256 rewardsAmount) = _getUserInfo(data);
-        _eventParam = abi.encode(_pid, _version, amount, rewardsAmount);
+		_withdrawAndHarvest(data, amount);
+		_eventName = "LogWithdrawAndHarvest(address,address,uint256,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			token1,
+			token2,
+			data.poolId,
+			data.version,
+			amount,
+			rewardsAmount
+		);
 	}
 
 	/**
@@ -148,7 +187,8 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 	function emergencyWithdraw(
 		address token1,
 		address token2,
-        uint256 setId
+		uint256 setId,
+		Metadata memory data
 	)
 		external
 		payable
@@ -156,16 +196,24 @@ abstract contract SushipswapIncentiveResolver is Helpers, Events {
 	{
 		token1 = changeEthAddrToWethAddr(token1);
 		token2 = changeEthAddrToWethAddr(token2);
-        (uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
+		if (data.poolId == uint256(-1) || data.version == 0) {
-        setUint(setId, _pid);
+			data = _getPoolId(token1, token2);
-        require(_pid != uint256(-1), "pool-does-not-exist");
+		}
-        (uint256 lpAmount, uint256 rewardsAmount) = _getUserInfo(
+		uint256 currentBal = _balance(token1, token2);
-            _pid,
+		require(data.poolId != uint256(-1), "pool-does-not-exist");
-            _version
+		(uint256 lpAmount, uint256 rewardsAmount) = _getUserInfo(data);
+		_emergencyWithdraw(data);
+		uint256 finalBal = _balance(token1, token2);
+		setUint(setId, uint256(currentBal - finalBal));
+		_eventName = "LogEmergencyWithdraw(address,address,uint256,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			token1,
+			token2,
+			data.poolId,
+			data.version,
+			lpAmount,
+			rewardsAmount
 		);
-        _emergencyWithdraw(_pid, _version);
-        _eventName = "LogEmergencyWithdraw(uint256,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_pid, _version, lpAmount, rewardsAmount);
 	}
 }
 

test/mainnet/sushiswapIncentive/sushiswapIncentive.test.ts

@@ -94,6 +94,12 @@ describe("Sushiswap", function () {
     });
 
     describe("Main", function () {
+        const data = {
+            poolId: 0,
+            version: 0, 
+            lpToken: ethers.constants.AddressZero
+        }
+
         it("Should deposit successfully", async function () {
             const ethAmount = ethers.utils.parseEther("2") // 1 ETH
             const daiUnitAmount = ethers.utils.parseEther("4000") // 1 ETH
@@ -134,7 +140,8 @@ describe("Sushiswap", function () {
                                 DAI_ADDR,
                                 ethers.utils.parseEther("10"),
                                 getId,
-                                setId
+                                setId,
+                                data
                             ]
                         }
                     ]
@@ -152,7 +159,8 @@ describe("Sushiswap", function () {
                             args: [
                                 WETH_ADDR,
                                 DAI_ADDR,
-                                setId
+                                setId,
+                                data
                             ]
                         }
                     ]
@@ -173,7 +181,8 @@ describe("Sushiswap", function () {
                                 DAI_ADDR,
                                 ethers.utils.parseEther("1"),
                                 getId,
-                                setId
+                                setId,
+                                data
                             ]
                         }
                     ]
@@ -194,7 +203,8 @@ describe("Sushiswap", function () {
                                 DAI_ADDR,
                                 ethers.utils.parseEther("1"),
                                 getId,
-                                setId
+                                setId,
+                                data
                             ]
                         }
                     ]