219 lines
8.8 KiB
TypeScript
219 lines
8.8 KiB
TypeScript
import { expect } from 'chai'
|
|
import hre from "hardhat";
|
|
import {
|
|
ZeroAddress,
|
|
getBytes,
|
|
solidityPackedKeccak256,
|
|
formatEther,
|
|
JsonRpcProvider,
|
|
} from 'ethers'
|
|
|
|
import {
|
|
loadFixture,
|
|
} from "@nomicfoundation/hardhat-toolbox/network-helpers";
|
|
import { expandDecimals, increaseTime, mineBlock, reportGasUsed } from './shared/utilities';
|
|
const secondsOneDay = BigInt(24 * 60 * 60);
|
|
const secondsPerYear = 365 * 24 * 60 * 60;
|
|
// 1.5 / (365*24*60*60)
|
|
const rewardPerSecond = BigInt(1.5 * 10 ** 18) / BigInt(secondsPerYear) ;
|
|
// 47564688000
|
|
console.log('rewardPerSecond: ', rewardPerSecond.toString())
|
|
|
|
const blockTime = async (provider: any) => {
|
|
const block = await provider.getBlock('latest')
|
|
return block ? block.timestamp : 0
|
|
}
|
|
const showLog = async (tag: string, stakedCecTracker: any, esCec: any, address: string) => {
|
|
console.log(tag+'\t', 'stake amount:', formatEther(await stakedCecTracker.stakedAmounts(address)),
|
|
'claimable: ', formatEther(await stakedCecTracker.claimable(address)),
|
|
'claimableReward: ', formatEther(await stakedCecTracker.claimableReward(address)),
|
|
'esCec balance: ', formatEther(await esCec.balanceOf(address)),
|
|
)
|
|
}
|
|
describe('RewardRouter', function() {
|
|
async function deployOneContract() {
|
|
// Contracts are deployed using the first signer/account by default
|
|
const [owner, user0, user1, user2] = await hre.ethers.getSigners();
|
|
const chainId = hre.network.config.chainId
|
|
|
|
const Cec = await hre.ethers.getContractFactory("MintableBaseToken");
|
|
const cec = await Cec.deploy("test cec", "cec");
|
|
const EsToken = await hre.ethers.getContractFactory("EsToken");
|
|
const esCec = await EsToken.deploy("test esCec", "esCec");
|
|
|
|
const RewardTracker = await hre.ethers.getContractFactory("RewardTracker");
|
|
const stakedCecTracker = await RewardTracker.deploy(esCec.target, cec.target, rewardPerSecond, 18);
|
|
|
|
const Vester = await hre.ethers.getContractFactory("Vester");
|
|
const vester = await Vester.deploy(
|
|
"Vested CEC",
|
|
"veCEC",
|
|
secondsPerYear,
|
|
esCec.target,
|
|
cec.target,
|
|
stakedCecTracker.target,
|
|
ZeroAddress,
|
|
false
|
|
);
|
|
|
|
await stakedCecTracker.setInPrivateStakingMode(true)
|
|
|
|
await esCec.setInPrivateTransferMode(true)
|
|
|
|
const RewardRouter = await hre.ethers.getContractFactory("RewardRouter");
|
|
const rewardRouter = await RewardRouter.deploy(
|
|
cec.target,
|
|
stakedCecTracker.target,
|
|
vester.target,
|
|
);
|
|
|
|
await esCec.setMinter(owner.address, true)
|
|
await esCec.setHandler(owner.address, true)
|
|
await esCec.mint(stakedCecTracker.target, expandDecimals(50000, 18))
|
|
|
|
await stakedCecTracker.setHandler(rewardRouter.target, true)
|
|
await esCec.setMinter(vester.target, true)
|
|
await esCec.setHandler(stakedCecTracker.target, true)
|
|
|
|
return { owner, user0, user1, user2, chainId, cec, esCec, stakedCecTracker, vester, rewardRouter };
|
|
}
|
|
describe("Deployment", function () {
|
|
it('should deploy RewardRouter', async function() {
|
|
const { chainId } = await loadFixture(deployOneContract);
|
|
// expect((await nftClaimer.mintConfig()).mintPrice).to.equal(100);
|
|
});
|
|
})
|
|
describe("Staking CEC", function () {
|
|
it("stakeCecForAccount, stakeCec, stakeEsCec, unstakeCec, unstakeEsCec, claimEsCec", async () => {
|
|
const {owner, user0, user1, user2, chainId, cec, esCec, stakedCecTracker, vester, rewardRouter} = await loadFixture(deployOneContract);
|
|
const wallet = owner
|
|
const provider = wallet.provider;
|
|
await cec.setMinter(wallet.address, true)
|
|
await cec.mint(user0.address, expandDecimals(1500, 18))
|
|
expect(await cec.balanceOf(user0.address)).eq(expandDecimals(1500, 18))
|
|
|
|
// @ts-ignore
|
|
await cec.connect(user0).approve(stakedCecTracker.target, expandDecimals(1000, 18))
|
|
|
|
// @ts-ignore
|
|
await expect(rewardRouter.connect(user0).batchStakeCecForAccount([user1.address], [expandDecimals(1000, 18)]))
|
|
.to.be.revertedWith("Governable: forbidden")
|
|
await rewardRouter.setGov(user0.address)
|
|
// @ts-ignore
|
|
await rewardRouter.connect(user0).batchStakeCecForAccount([user1.address], [expandDecimals(800, 18)])
|
|
let startTime = await blockTime(provider)
|
|
console.log('startTime: ', startTime)
|
|
expect(await cec.balanceOf(user0.address)).eq(expandDecimals(700, 18))
|
|
|
|
await cec.mint(user1.address, expandDecimals(200, 18))
|
|
expect(await cec.balanceOf(user1.address)).eq(expandDecimals(200, 18))
|
|
let nowTime = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
let reward = BigInt(800) * BigInt(nowTime - startTime) * rewardPerSecond
|
|
//@ts-ignore
|
|
expect(await stakedCecTracker.claimable(user1.address)).eq(reward)
|
|
// @ts-ignore
|
|
await cec.connect(user1).approve(stakedCecTracker.target, expandDecimals(200, 18))
|
|
// @ts-ignore
|
|
await rewardRouter.connect(user1).stakeCec(expandDecimals(200, 18))
|
|
let preTime = nowTime
|
|
nowTime = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
let _reward = BigInt(800) * BigInt(nowTime - preTime) * rewardPerSecond
|
|
reward += _reward
|
|
expect(await stakedCecTracker.claimable(user1.address)).eq(reward)
|
|
expect(await cec.balanceOf(user1.address)).eq(0)
|
|
|
|
expect(await stakedCecTracker.stakedAmounts(user0.address)).eq(0)
|
|
expect(await stakedCecTracker.stakedAmounts(user1.address)).eq(expandDecimals(1000, 18))
|
|
|
|
await showLog('init', stakedCecTracker, esCec, user1.address)
|
|
await increaseTime(provider, Number(secondsOneDay))
|
|
await mineBlock(provider)
|
|
await showLog('1day', stakedCecTracker, esCec, user1.address)
|
|
expect(await stakedCecTracker.claimable(user0.address)).eq(0)
|
|
console.log('blockTime: ', await blockTime(provider))
|
|
preTime = nowTime
|
|
nowTime = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
_reward = BigInt(1000) * BigInt(nowTime - preTime) * rewardPerSecond
|
|
reward += _reward
|
|
expect(await stakedCecTracker.claimable(user1.address)).eq(reward)
|
|
|
|
await increaseTime(provider, 20)
|
|
await mineBlock(provider)
|
|
|
|
// await timelock.processMint(esCec.target, tokenManager.address, expandDecimals(500, 18))
|
|
// await esCec.connect(tokenManager).transferFrom(tokenManager.address, user2.address, expandDecimals(500, 18))
|
|
await cec.mint(user2.address, expandDecimals(500, 18))
|
|
// @ts-ignore
|
|
await cec.connect(user2).approve(stakedCecTracker.target, expandDecimals(500, 18))
|
|
// @ts-ignore
|
|
await rewardRouter.connect(user2).stakeCec(expandDecimals(500, 18))
|
|
let startTime2 = await blockTime(provider)
|
|
|
|
expect(await stakedCecTracker.stakedAmounts(user0.address)).eq(0)
|
|
expect(await stakedCecTracker.stakedAmounts(user1.address)).eq(expandDecimals(1000, 18))
|
|
expect(await stakedCecTracker.stakedAmounts(user2.address)).eq(expandDecimals(500, 18))
|
|
|
|
|
|
|
|
await increaseTime(provider, Number(secondsOneDay))
|
|
await mineBlock(provider)
|
|
|
|
expect(await stakedCecTracker.claimable(user0.address)).eq(0)
|
|
|
|
preTime = nowTime
|
|
nowTime = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
_reward = BigInt(1000) * BigInt(nowTime - preTime) * rewardPerSecond
|
|
reward += _reward
|
|
expect(await stakedCecTracker.claimable(user1.address)).eq(reward)
|
|
|
|
let preTime2 = startTime2
|
|
let nowTime2 = await blockTime(provider)
|
|
let reward2 = BigInt(500) * BigInt(nowTime2 - preTime2) * rewardPerSecond
|
|
expect(await stakedCecTracker.claimable(user2.address)).eq(reward2)
|
|
|
|
await showLog('2day', stakedCecTracker, esCec, user1.address)
|
|
|
|
expect(await esCec.balanceOf(user1.address)).eq(0)
|
|
// @ts-ignore
|
|
await rewardRouter.connect(user1).claim()
|
|
preTime = nowTime
|
|
nowTime = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
_reward = BigInt(1000) * BigInt(nowTime - preTime) * rewardPerSecond
|
|
reward += _reward
|
|
|
|
expect(await esCec.balanceOf(user1.address)).eq(reward)
|
|
expect(await stakedCecTracker.claimable(user1.address)).eq(0)
|
|
|
|
|
|
expect(await esCec.balanceOf(user2.address)).eq(0)
|
|
// @ts-ignore
|
|
await rewardRouter.connect(user2).claim()
|
|
preTime = nowTime2
|
|
nowTime2 = await blockTime(provider)
|
|
console.log('nowTime: ', nowTime)
|
|
reward2 = BigInt(500) * BigInt(nowTime2 - preTime2) * rewardPerSecond
|
|
|
|
expect(await esCec.balanceOf(user2.address)).eq(reward2)
|
|
|
|
|
|
|
|
await increaseTime(provider, Number(secondsOneDay))
|
|
await mineBlock(provider)
|
|
|
|
|
|
|
|
await increaseTime(provider, Number(secondsOneDay))
|
|
await mineBlock(provider)
|
|
await showLog('claim cec 2day', stakedCecTracker, esCec, user1.address)
|
|
|
|
//@ts-ignore
|
|
await rewardRouter.connect(user1).claim()
|
|
|
|
})
|
|
})
|
|
}) |