feat/implement sushiswap double incentive

This commit is contained in:
cryptoDev222 2021-10-22 09:29:32 -05:00 committed by pradyuman-verma
parent 102be3a91c
commit 650009f45e
8 changed files with 694 additions and 49 deletions

View File

@ -8,6 +8,7 @@ interface TokenInterface {
function withdraw(uint) external;
function balanceOf(address) external view returns (uint);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
}
interface MemoryInterface {

View File

@ -0,0 +1,36 @@
pragma solidity ^0.7.0;
contract Events {
event LogDeposit(
address indexed user,
uint256 indexed pid,
uint256 indexed version,
uint256 amount
);
event LogWithdraw(
address indexed user,
uint256 indexed pid,
uint256 indexed version,
uint256 amount
);
event LogEmergencyWithdraw(
address indexed user,
uint256 indexed pid,
uint256 indexed version,
uint256 lpAmount,
uint256 rewardsAmount
);
event LogHarvest(
address indexed user,
uint256 indexed pid,
uint256 indexed version,
uint256 amount
);
event LogWithdrawAndHarvest(
address indexed user,
uint256 indexed pid,
uint256 indexed version,
uint256 widrawAmount,
uint256 harvestAmount
);
}

View File

@ -0,0 +1,88 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import {DSMath} from "../../common/math.sol";
import {Basic} from "../../common/basic.sol";
import "./interface.sol";
contract Helpers is DSMath, Basic {
IMasterChefV2 immutable masterChefV2 =
IMasterChefV2(0xEF0881eC094552b2e128Cf945EF17a6752B4Ec5d);
IMasterChef immutable masterChef =
IMasterChef(0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd);
ISushiSwapFactory immutable factory =
ISushiSwapFactory(0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac);
function _deposit(uint256 _pid, uint256 _amount, uint256 _version) internal {
if(_version == 2)
masterChefV2.deposit(_pid, _amount, address(this));
else
masterChef.deposit(_pid, _amount);
}
function _withdraw(uint256 _pid, uint256 _amount, uint256 _version) internal {
if(_version == 2)
masterChefV2.withdraw(_pid, _amount, address(this));
else
masterChef.withdraw(_pid, _amount);
}
function _harvest(uint256 _pid) internal {
masterChefV2.harvest(_pid, address(this));
}
function _withdrawAndHarvest(uint256 _pid, uint256 _amount, uint256 _version) internal {
if(_version == 2)
masterChefV2.withdrawAndHarvest(_pid, _amount, address(this));
else _withdraw(_pid, _amount, _version);
}
function _emergencyWithdraw(uint256 _pid, uint256 _version) internal {
if(_version == 2)
masterChefV2.emergencyWithdraw(_pid, address(this));
else
masterChef.emergencyWithdraw(_pid, address(this));
}
function _getPoolId(address tokenA, address tokenB)
internal
view
returns (uint256 poolId, uint256 version, address lpToken)
{
address pair = factory.getPair(tokenA, tokenB);
uint256 length = masterChefV2.poolLength();
version = 2;
poolId = uint256(-1);
for (uint256 i = 0; i < length; i++) {
lpToken = masterChefV2.lpToken(i);
if (pair == lpToken) {
poolId = i;
break;
}
}
uint256 lengthV1 = masterChef.poolLength();
for (uint256 i = 0; i < lengthV1; i++) {
(lpToken, , , ) = masterChef.poolInfo(i);
if (pair == lpToken) {
poolId = i;
version = 1;
break;
}
}
}
function _getUserInfo(uint256 _pid, uint256 _version)
internal
view
returns (uint256 lpAmount, uint256 rewardsAmount)
{
if(_version == 2)
(lpAmount, rewardsAmount) = masterChefV2.userInfo(_pid, address(this));
else
(lpAmount, rewardsAmount) = masterChef.userInfo(_pid, address(this));
}
}

View File

@ -0,0 +1,94 @@
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "./libraries/IERC20.sol";
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
}
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. SUSHIs to distribute per block.
uint256 lastRewardBlock; // Last block number that SUSHIs distribution occurs.
uint256 accSushiPerShare; // Accumulated SUSHIs per share, times 1e12. See below.
}
interface IMasterChef {
function poolLength() external view returns (uint256);
function updatePool(uint256 pid) external returns (PoolInfo memory);
function poolInfo(uint256 pid) external view returns (address, uint256, uint256, uint256);
function userInfo(uint256 _pid, address _user)
external
view
returns (uint256, uint256);
function deposit(
uint256 pid,
uint256 amount
) external;
function withdraw(
uint256 pid,
uint256 amount
) external;
function emergencyWithdraw(uint256 pid, address to) external;
}
interface IMasterChefV2 {
function poolLength() external view returns (uint256);
function updatePool(uint256 pid) external returns (PoolInfo memory);
function lpToken(uint256 pid) external view returns (address);
function userInfo(uint256 _pid, address _user)
external
view
returns (uint256, uint256);
function deposit(
uint256 pid,
uint256 amount,
address to
) external;
function withdraw(
uint256 pid,
uint256 amount,
address to
) external;
function emergencyWithdraw(uint256 pid, address to) external;
function harvest(uint256 pid, address to) external;
function withdrawAndHarvest(
uint256 pid,
uint256 amount,
address to
) external;
}
interface ISushiSwapFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}

View File

@ -0,0 +1,146 @@
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/**
* @title SushiSwap Double Incentive.
* @dev Decentralized Exchange.
*/
import {TokenInterface} from "../../common/interfaces.sol";
import {Helpers} from "./helpers.sol";
import {Events} from "./events.sol";
abstract contract SushipswapIncentiveResolver is Helpers, Events {
/**
* @dev deposit LP token to masterChef
* @param token1 token1 of LP token
* @param token2 token2 of LP token
* @param amount amount of LP token
* @param getId ID to retrieve amount
* @param setId ID stores Pool ID
*/
function deposit(
address token1,
address token2,
uint256 amount,
uint256 getId,
uint256 setId
) external {
amount = getUint(getId, amount);
(uint256 _pid, uint256 _version, address lpTokenAddr) = _getPoolId(
token1,
token2
);
setUint(setId, _pid);
require(_pid != uint256(-1), "pool-does-not-exist");
TokenInterface lpToken = TokenInterface(lpTokenAddr);
lpToken.approve(address(masterChef), amount);
_deposit(_pid, amount, _version);
emit LogDeposit(address(this), _pid, _version, amount);
}
/**
* @dev withdraw LP token from masterChef
* @param token1 token1 of LP token
* @param token2 token2 of LP token
* @param amount amount of LP token
* @param getId ID to retrieve amount
* @param setId ID stores Pool ID
*/
function withdraw(
address token1,
address token2,
uint256 amount,
uint256 getId,
uint256 setId
) external {
amount = getUint(getId, amount);
(uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
setUint(setId, _pid);
require(_pid != uint256(-1), "pool-does-not-exist");
_withdraw(_pid, amount, _version);
emit LogWithdraw(address(this), _pid, _version, amount);
}
/**
* @dev harvest from masterChef
* @param token1 token1 deposited of LP token
* @param token2 token2 deposited LP token
* @param setId ID stores Pool ID
*/
function harvest(
address token1,
address token2,
uint256 setId
) external {
(uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
setUint(setId, _pid);
require(_pid != uint256(-1), "pool-does-not-exist");
(, uint256 rewardsAmount) = _getUserInfo(_pid, _version);
if (_version == 2) _harvest(_pid);
else _withdraw(_pid, 0, _version);
emit LogHarvest(address(this), _pid, _version, rewardsAmount);
}
/**
* @dev withdraw LP token and harvest from masterChef
* @param token1 token1 of LP token
* @param token2 token2 of LP token
* @param amount amount of LP token
* @param getId ID to retrieve amount
* @param setId ID stores Pool ID
*/
function withdrawAndHarvest(
address token1,
address token2,
uint256 amount,
uint256 getId,
uint256 setId
) external {
amount = getUint(getId, amount);
(uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
setUint(setId, _pid);
require(_pid != uint256(-1), "pool-does-not-exist");
(, uint256 rewardsAmount) = _getUserInfo(_pid, _version);
_withdrawAndHarvest(_pid, amount, _version);
emit LogWithdrawAndHarvest(
address(this),
_pid,
_version,
amount,
rewardsAmount
);
}
/**
* @dev emergency withdraw from masterChef
* @param token1 token1 deposited of LP token
* @param token2 token2 deposited LP token
* @param setId ID stores Pool ID
*/
function emergencyWithdraw(
address token1,
address token2,
uint256 setId
) external {
(uint256 _pid, uint256 _version, ) = _getPoolId(token1, token2);
setUint(setId, _pid);
require(_pid != uint256(-1), "pool-does-not-exist");
(uint256 lpAmount, uint256 rewardsAmount) = _getUserInfo(
_pid,
_version
);
_emergencyWithdraw(_pid, _version);
emit LogEmergencyWithdraw(
address(this),
_pid,
_version,
lpAmount,
rewardsAmount
);
}
}
contract ConnectV2SushiswapIncentive is SushipswapIncentiveResolver {
string public constant name = "SushipswapIncentive-v1.1";
}

90
hardhat.config.js Normal file
View File

@ -0,0 +1,90 @@
require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-ethers");
require("@tenderly/hardhat-tenderly");
require("@nomiclabs/hardhat-etherscan");
require("@nomiclabs/hardhat-web3");
require("hardhat-deploy");
require("hardhat-deploy-ethers");
require("dotenv").config();
const { utils } = require("ethers");
const PRIVATE_KEY = process.env.PRIVATE_KEY;
const ALCHEMY_ID = process.env.ALCHEMY_ID;
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY;
if (!process.env.ALCHEMY_ID) {
throw new Error("ENV Variable ALCHEMY_ID not set!");
}
/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
solidity: {
compilers: [
{
version: "0.7.6",
settings: {
optimizer: {
enabled: true,
runs: 200,
},
},
},
{
version: "0.6.0",
},
{
version: "0.6.2",
},
{
version: "0.6.12",
},
{
version: "0.6.5",
},
],
},
networks: {
// defaultNetwork: "hardhat",
kovan: {
url: `https://eth-kovan.alchemyapi.io/v2/${ALCHEMY_ID}`,
accounts: [`0x${PRIVATE_KEY}`],
},
mainnet: {
url: `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_ID}`,
accounts: [`0x${PRIVATE_KEY}`],
timeout: 150000,
gasPrice: parseInt(utils.parseUnits("30", "gwei")),
},
rinkeby: {
url: `https://eth-rinkeby.alchemyapi.io/v2/${ALCHEMY_ID}`,
accounts: [`0x${PRIVATE_KEY}`],
timeout: 150000,
},
hardhat: {
forking: {
url: `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_ID}`,
blockNumber: 12696000,
},
blockGasLimit: 12000000,
},
matic: {
url: "https://rpc-mainnet.maticvigil.com/",
accounts: [`0x${PRIVATE_KEY}`],
timeout: 150000,
gasPrice: parseInt(utils.parseUnits("1", "gwei")),
},
},
etherscan: {
apiKey: ETHERSCAN_API_KEY,
},
tenderly: {
project: process.env.TENDERLY_PROJECT,
username: process.env.TENDERLY_USERNAME,
},
mocha: {
timeout: 100 * 1000,
},
};

View File

@ -1,44 +1,21 @@
const { expect } = require("chai");
const hre = require("hardhat");
const { web3, deployments, waffle, ethers } = hre;
const { provider, deployContract } = waffle
const { waffle, ethers } = hre;
const { provider } = waffle
const deployAndEnableConnector = require("../../scripts/deployAndEnableConnector.js")
const buildDSAv2 = require("../../scripts/buildDSAv2")
const encodeSpells = require("../../scripts/encodeSpells.js")
const encodeFlashcastData = require("../../scripts/encodeFlashcastData.js")
const getMasterSigner = require("../../scripts/getMasterSigner")
const addLiquidity = require("../../scripts/addLiquidity");
const addresses = require("../../scripts/constant/addresses");
const abis = require("../../scripts/constant/abis");
const constants = require("../../scripts/constant/constant");
const tokens = require("../../scripts/constant/tokens");
const { abi: nftManagerAbi } = require("@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json")
const connectV2SushiswapArtifacts = require("../../artifacts/contracts/mainnet/connectors/sushiswap/main.sol/ConnectV2Sushiswap.json");
const { eth } = require("../../scripts/constant/tokens");
const { BigNumber } = require("ethers");
const FeeAmount = {
LOW: 500,
MEDIUM: 3000,
HIGH: 10000,
}
const TICK_SPACINGS = {
500: 10,
3000: 60,
10000: 200
}
const USDT_ADDR = "0xdac17f958d2ee523a2206206994597c13d831ec7"
const DAI_ADDR = "0x6b175474e89094c44da98b954eedeac495271d0f"
let tokenIds = []
let liquidities = []
const abiCoder = ethers.utils.defaultAbiCoder
describe("Sushiswap", function () {
const connectorName = "Sushiswap-v1"
@ -134,30 +111,6 @@ describe("Sushiswap", function () {
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address)
let receipt = await tx.wait()
// let castEvent = new Promise((resolve, reject) => {
// dsaWallet0.on('LogCast', (origin, sender, value, targetNames, targets, eventNames, eventParams, event) => {
// const params = abiCoder.decode(["uint256", "uint256", "uint256", "uint256", "int24", "int24"], eventParams[0]);
// const params1 = abiCoder.decode(["uint256", "uint256", "uint256", "uint256", "int24", "int24"], eventParams[2]);
// tokenIds.push(params[0]);
// tokenIds.push(params1[0]);
// liquidities.push(params[1]);
// event.removeListener();
// resolve({
// eventNames,
// });
// });
// setTimeout(() => {
// reject(new Error('timeout'));
// }, 60000)
// });
// let event = await castEvent
// const data = await nftManager.positions(tokenIds[0])
// expect(data.liquidity).to.be.equals(liquidities[0]);
}).timeout(10000000000);
it("Should withdraw successfully", async function () {

View File

@ -0,0 +1,237 @@
const { expect } = require("chai");
const hre = require("hardhat");
const { waffle, ethers } = hre;
const { provider } = waffle
const deployAndEnableConnector = require("../../scripts/deployAndEnableConnector.js")
const buildDSAv2 = require("../../scripts/buildDSAv2")
const encodeSpells = require("../../scripts/encodeSpells.js")
const getMasterSigner = require("../../scripts/getMasterSigner")
const addLiquidity = require("../../scripts/addLiquidity");
const addresses = require("../../scripts/constant/addresses");
const abis = require("../../scripts/constant/abis");
const connectV2SushiswapArtifacts = require("../../artifacts/contracts/mainnet/connectors/sushiswap/main.sol/ConnectV2Sushiswap.json");
const connectV2SushiswapIncentiveArtifacts = require("../../artifacts/contracts/mainnet/connectors/sushi-incentive/main.sol/ConnectV2SushiswapIncentive.json");
const DAI_ADDR = "0x6b175474e89094c44da98b954eedeac495271d0f"
const WETH_ADDR = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
describe("Sushiswap", function () {
const connectorName = "Sushiswap-v1"
const incentiveConnectorName = "Sushiswp-Incentive-v1"
let dsaWallet0
let masterSigner;
let instaConnectorsV2;
let connector, connectorIncentive;
const wallets = provider.getWallets()
const [wallet0, wallet1, wallet2, wallet3] = wallets
before(async () => {
await hre.network.provider.request({
method: "hardhat_reset",
params: [
{
forking: {
jsonRpcUrl: hre.config.networks.hardhat.forking.url,
blockNumber: 13005785,
},
},
],
});
masterSigner = await getMasterSigner(wallet3)
instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2);
connector = await deployAndEnableConnector({
connectorName,
contractArtifact: connectV2SushiswapArtifacts,
signer: masterSigner,
connectors: instaConnectorsV2
})
console.log("Connector address", connector.address)
connectorIncentive = await deployAndEnableConnector({
connectorName: incentiveConnectorName,
contractArtifact: connectV2SushiswapIncentiveArtifacts,
signer: masterSigner,
connectors: instaConnectorsV2
})
console.log("Incentive Connector address", connectorIncentive.address)
})
it("Should have contracts deployed.", async function () {
expect(!!instaConnectorsV2.address).to.be.true;
expect(!!connector.address).to.be.true;
expect(!!masterSigner.address).to.be.true;
});
describe("DSA wallet setup", function () {
it("Should build DSA v2", async function () {
dsaWallet0 = await buildDSAv2(wallet0.address)
expect(!!dsaWallet0.address).to.be.true;
});
it("Deposit ETH & DAI into DSA wallet", async function () {
await wallet0.sendTransaction({
to: dsaWallet0.address,
value: ethers.utils.parseEther("10")
});
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("10"));
await addLiquidity("dai", dsaWallet0.address, ethers.utils.parseEther("100000"));
});
it("Deposit ETH & USDT into DSA wallet", async function () {
await wallet0.sendTransaction({
to: dsaWallet0.address,
value: ethers.utils.parseEther("10")
});
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("10"));
await addLiquidity("usdt", dsaWallet0.address, ethers.utils.parseEther("100000"));
});
});
describe("Main", function () {
it("Should deposit successfully", async function () {
const ethAmount = ethers.utils.parseEther("2") // 1 ETH
const daiUnitAmount = ethers.utils.parseEther("4000") // 1 ETH
const usdtAmount = ethers.utils.parseEther("400") / Math.pow(10, 12) // 1 ETH
const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
const getId = "0"
const setId = "0"
const spells = [
{
connector: connectorName,
method: "deposit",
args: [
ethAddress,
DAI_ADDR,
ethAmount,
daiUnitAmount,
"500000000000000000",
getId,
setId
],
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address)
await tx.wait()
describe("Incentive", () => {
it("Should deposit successfully", async () => {
const getId = 0
const setId = 0
const spells = [
{
connector: incentiveConnectorName,
method: "deposit",
args: [
WETH_ADDR,
DAI_ADDR,
ethers.utils.parseEther("10"),
getId,
setId
]
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address)
await tx.wait();
})
it("Should harvest successfully", async () => {
const setId = 0
const spells = [
{
connector: incentiveConnectorName,
method: "harvest",
args: [
WETH_ADDR,
DAI_ADDR,
setId
]
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address)
await tx.wait();
})
it("Should harvest and withdraw successfully", async () => {
const getId = 0
const setId = 0
const spells = [
{
connector: incentiveConnectorName,
method: "withdrawAndHarvest",
args: [
WETH_ADDR,
DAI_ADDR,
ethers.utils.parseEther("1"),
getId,
setId
]
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address)
await tx.wait();
})
it("Should withdraw successfully", async () => {
const getId = 0
const setId = 0
const spells = [
{
connector: incentiveConnectorName,
method: "withdraw",
args: [
WETH_ADDR,
DAI_ADDR,
ethers.utils.parseEther("1"),
getId,
setId
]
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address)
await tx.wait();
})
})
}).timeout(10000000000);
it("Should buy successfully", async function () {
const ethAmount = ethers.utils.parseEther("0.1") // 1 ETH
const daiUnitAmount = ethers.utils.parseEther("4000") // 1 ETH
const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
const getId = "0"
const setId = "0"
const spells = [
{
connector: connectorName,
method: "buy",
args: [
ethAddress,
DAI_ADDR,
ethAmount,
daiUnitAmount,
getId,
setId
]
}
]
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address)
let receipt = await tx.wait()
});
});
})