Tests WIP

Author: SigismundSchlomo

contracts/staking/token/SingleSidePool.sol

@@ -15,8 +15,6 @@ contract SingleSidePool is Initializable, AccessControl, IOnBlockListener {
 
     struct Config {
         IERC20 token;
-        RewardsBank rewardsBank;
-        LockKeeper lockKeeper;
         string name;
         address rewardToken; 
         uint rewardTokenPrice; // The coefficient to calculate the reward token amount
@@ -42,6 +40,8 @@ contract SingleSidePool is Initializable, AccessControl, IOnBlockListener {
     }
 
     bool public active;
+    RewardsBank rewardsBank;
+    LockKeeper lockKeeper;
 
     Config public config;
     Info public info;
@@ -63,7 +63,9 @@ contract SingleSidePool is Initializable, AccessControl, IOnBlockListener {
     event UnstakeLocked(address indexed user, uint amount, uint unlockTime, uint creationTime);
     event UnstakeFast(address indexed user, uint amount, uint penalty);
 
-    function initialize(Config calldata config_) public  initializer {
+    function initialize(RewardsBank bank_, LockKeeper keeper_, Config calldata config_) public  initializer {
+        rewardsBank = bank_;
+        lockKeeper = keeper_;
         config = config_;
 
         info.lastInterestUpdate = block.timestamp;
@@ -133,13 +135,13 @@ contract SingleSidePool is Initializable, AccessControl, IOnBlockListener {
 
         // cancel previous lock (if exists). canceledAmount will be added to new lock
         uint canceledAmount;
-        if (config.lockKeeper.getLock(stakers[msg.sender].lockedWithdrawal).totalClaims > 0) // prev lock exists
-            canceledAmount = config.lockKeeper.cancelLock(stakers[msg.sender].lockedWithdrawal);
+        if (lockKeeper.getLock(stakers[msg.sender].lockedWithdrawal).totalClaims > 0) // prev lock exists
+            canceledAmount = lockKeeper.cancelLock(stakers[msg.sender].lockedWithdrawal);
 
-        config.token.approve(address(config.lockKeeper), amount + canceledAmount);
+        config.token.approve(address(lockKeeper), amount + canceledAmount);
 
         // lock funds
-        stakers[msg.sender].lockedWithdrawal = config.lockKeeper.lockSingle(
+        stakers[msg.sender].lockedWithdrawal = lockKeeper.lockSingle(
             msg.sender, address(config.token), uint64(block.timestamp + config.lockPeriod), amount + canceledAmount,
             string(abi.encodePacked("TokenStaking unstake: ", _addressToString(address(config.token))))
         );
@@ -252,7 +254,7 @@ contract SingleSidePool is Initializable, AccessControl, IOnBlockListener {
         stakers[user].claimableRewards = 0;
 
         uint rewardTokenAmount = amount * config.rewardTokenPrice;
-        config.rewardsBank.withdrawErc20(config.rewardToken, payable(user), rewardTokenAmount);
+        rewardsBank.withdrawErc20(config.rewardToken, payable(user), rewardTokenAmount);
         emit Claim(user, rewardTokenAmount);
     }
 

contracts/staking/token/TokenPoolsManager.sol

@@ -41,8 +41,8 @@ contract TokenPoolsManager is AccessControl{
     function createSingleSidePool(SingleSidePool.Config calldata params) public onlyRole(DEFAULT_ADMIN_ROLE) returns (address) {
         console.log("Entered createPool");
         bytes memory data = abi.encodeWithSignature(
-            "initialize((address,address,address,string,address,uint256,uint256,uint256,uint256,uint256,uint256))",
-            params);
+            "initialize(address,address,(address,string,address,uint256,uint256,uint256,uint256,uint256,uint256))",
+            bank, lockKeeper, params);
         address pool = address(new BeaconProxy(address(singleSideBeacon), data));
         console.log("Pool created at address: %s", pool);
         pools[params.name] = pool;

test/staking/token/TokenPoolsManager.ts

@@ -6,9 +6,11 @@ import {
   TokenPoolsManager,
   RewardsBank,
   AirBond__factory,
+  SingleSidePool,
   RewardsBank__factory,
   TokenPoolsManager__factory,
   LockKeeper__factory,
+  LockKeeper,
 } from "../../../typechain-types";
 
 import SignleSidePoolJson from "../../../artifacts/contracts/staking/token/SingleSidePool.sol/SingleSidePool.json";
@@ -20,6 +22,7 @@ describe("PoolsManager", function () {
   let rewardsBank: RewardsBank;
   let tokenAddr: string;
   let owner: SignerWithAddress;
+  let lockKeeper: LockKeeper;
 
   async function deploy() {
     const [owner] = await ethers.getSigners();
@@ -41,24 +44,29 @@ describe("PoolsManager", function () {
     await (await rewardsBank.grantRole(await rewardsBank.DEFAULT_ADMIN_ROLE(), poolsManager.address)).wait();
     const tokenAddr = airBond.address;
 
-    return { poolsManager, rewardsBank, tokenAddr, owner };
+    return { poolsManager, rewardsBank, lockKeeper, tokenAddr, owner };
   }
 
   beforeEach(async function () {
-    ({ poolsManager, rewardsBank, tokenAddr, owner } = await loadFixture(deploy));
+    ({ poolsManager, rewardsBank, lockKeeper, tokenAddr, owner } = await loadFixture(deploy));
   });
 
-  describe("Pool Management", function () {
-    it("Should allow the owner to create a pool", async function () {
-      const minStakeValue = 10;
-      const fastUnstakePenalty = 100000; // 10%
-      const interest = 100000; // 10%
-      const interestRate = 24 * 60 * 60; // 24 hours
-      const lockPeriod = 24 * 60 * 60; // 24 hours
-      const rewardsTokenPrice = 1;
+  describe("SingleSidePool Management", function () {
+    it("Should allow the owner to create a single side pool", async function () {
+      const singleSidePoolConfig: SingleSidePool.ConfigStruct = {
+        token: tokenAddr,
+        name: "TestPool",
+        minStakeValue: 10,
+        rewardToken: tokenAddr,
+        rewardTokenPrice: 1,
+        fastUnstakePenalty: 100000, // 10%
+        interest: 100000, // 10%
+        interestRate: 24 * 60 * 60, // 24 hours
+        lockPeriod: 24 * 60 * 60, // 24 hours
+      };
 
       console.log("before createPool");
-      const tx = await poolsManager.createPool(tokenAddr, "TestProxy", minStakeValue, fastUnstakePenalty, interest, interestRate, lockPeriod, tokenAddr, rewardsTokenPrice);
+      const tx = await poolsManager.createSingleSidePool(singleSidePoolConfig);
       const receipt = await tx.wait();
       console.log("Receipt: ", receipt);
       const poolAddress = receipt.events![4].args![1];
@@ -67,14 +75,19 @@ describe("PoolsManager", function () {
     });
 
     it("Should activate and deactivate a pool", async function () {
-      const minStakeValue = 10;
-      const fastUnstakePenalty = 100000; // 10%
-      const interest = 100000; // 10%
-      const interestRate = 24 * 60 * 60; // 24 hours
-      const lockPeriod = 24 * 60 * 60; // 24 hours
-      const rewardsTokenPrice = 1;
-
-      await poolsManager.createPool(tokenAddr, "TestProxy", minStakeValue, fastUnstakePenalty, interest, interestRate, lockPeriod, tokenAddr, rewardsTokenPrice);
+      const singleSidePoolConfig: SingleSidePool.ConfigStruct = {
+        token: tokenAddr,
+        name: "TestPool",
+        minStakeValue: 10,
+        rewardToken: tokenAddr,
+        rewardTokenPrice: 1,
+        fastUnstakePenalty: 100000, // 10%
+        interest: 100000, // 10%
+        interestRate: 24 * 60 * 60, // 24 hours
+        lockPeriod: 24 * 60 * 60, // 24 hours
+      };
+
+      await poolsManager.createSingleSidePool(tokenAddr, "TestProxy", minStakeValue, fastUnstakePenalty, interest, interestRate, lockPeriod, tokenAddr, rewardsTokenPrice);
       const poolAddress = await poolsManager.getPoolAddress("TestProxy");
       console.log("Pool Address: ", poolAddress);