From a8d0e07512083fae068e4426f78fd062bb2f071d Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Tue, 19 Mar 2024 23:15:56 +0530
Subject: [PATCH 01/16] made PayFee public

---
 contracts/FeeBaseHelper.sol | 2 +-
 package-lock.json           | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index 3b2b909..8b3537e 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -13,7 +13,7 @@ contract FeeBaseHelper is ERC20Helper, GovManager {
     address public FeeToken;
     mapping(address => uint256) public Reserve;
 
-    function PayFee(uint256 _fee) external payable firewallProtected {
+    function PayFee(uint256 _fee) public payable firewallProtected {
         if (_fee == 0) return;
         if (FeeToken == address(0)) {
             require(msg.value >= _fee, "Not Enough Fee Provided");
diff --git a/package-lock.json b/package-lock.json
index c16f605..9dec2ff 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@poolzfinance/poolz-helper-v2",
-  "version": "2.3.1",
+  "version": "2.3.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@poolzfinance/poolz-helper-v2",
-      "version": "2.3.1",
+      "version": "2.3.5",
       "license": "MIT",
       "dependencies": {
         "@ethersproject/bignumber": "^5.7.0",

From d96cc806ec7327abb5807c19de4891c55fb749a0 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Wed, 20 Mar 2024 23:55:14 +0530
Subject: [PATCH 02/16] progress with tests

---
 contracts/FeeBaseHelper.sol   | 69 +++++++++++++++++++++++++----------
 contracts/mocks/FeeHelper.sol | 29 ++-------------
 test/3_Fee.ts                 | 38 +++++++++----------
 3 files changed, 71 insertions(+), 65 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index 8b3537e..1175996 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -3,46 +3,77 @@ pragma solidity ^0.8.0;
 
 import "./ERC20Helper.sol";
 import "./GovManager.sol";
+import "./interfaces/IWhiteList.sol";
 
-contract FeeBaseHelper is ERC20Helper, GovManager {
-    event TransferInETH(uint256 Amount, address From);
-    event NewFeeAmount(uint256 NewFeeAmount, uint256 OldFeeAmount);
+abstract contract FeeBaseHelper is ERC20Helper, GovManager {
+    event TransferInETH(uint Amount, address From);
+    event NewFeeAmount(uint NewFeeAmount, uint OldFeeAmount);
     event NewFeeToken(address NewFeeToken, address OldFeeToken);
 
-    uint256 public Fee;
+    error NotEnoughFeeProvided();
+    error FeeAmountIsZero();
+    error TransferFailed();
+
+    uint public FeeAmount;
+    uint public WhiteListId;
     address public FeeToken;
-    mapping(address => uint256) public Reserve;
+    address public WhiteListAddress;
+    mapping(address => uint) public FeeReserve;
 
-    function PayFee(uint256 _fee) public payable firewallProtected {
-        if (_fee == 0) return;
+    function TakeFee() internal virtual firewallProtected {
+        uint feeToPay = FeeAmount;
+        if(feeToPay == 0) return;
+        uint credits = getCredits(msg.sender);
+        if(credits > 0) {
+            if(credits < feeToPay) {
+                feeToPay -= credits;
+                IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, credits);
+            } else {
+                feeToPay = 0;
+                IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, feeToPay);
+            }
+        }
+        if( feeToPay == 0 ) return;
         if (FeeToken == address(0)) {
-            require(msg.value >= _fee, "Not Enough Fee Provided");
+            if (msg.value < feeToPay) revert NotEnoughFeeProvided();
             emit TransferInETH(msg.value, msg.sender);
         } else {
-            TransferInToken(FeeToken, msg.sender, _fee);
+            TransferInToken(FeeToken, msg.sender, feeToPay);
         }
-        Reserve[FeeToken] += _fee;
+        FeeReserve[FeeToken] += feeToPay;
+    }
+
+    function getCredits(address _user) public view returns(uint) {
+        if(WhiteListAddress == address(0) || WhiteListId == 0) return 0;
+        return IWhiteList(WhiteListAddress).Check(_user, WhiteListId);
     }
 
-    function SetFeeAmount(uint256 _amount) external firewallProtected onlyOwnerOrGov {
-        require(Fee != _amount, "Can't swap to same fee value");
-        emit NewFeeAmount(_amount, Fee);
-        Fee = _amount;
+    function SetFeeAmount(uint _amount) external firewallProtected onlyOwnerOrGov {
+        emit NewFeeAmount(_amount, FeeAmount);
+        FeeAmount = _amount;
     }
 
     function SetFeeToken(address _token) external firewallProtected onlyOwnerOrGov {
-        require(FeeToken != _token, "Can't swap to same token");
         emit NewFeeToken(_token, FeeToken);
         FeeToken = _token; // set address(0) to use ETH/BNB as main coin
     }
 
+    function setWhiteListAddress(address _whiteListAddr) public onlyOwnerOrGov {
+        WhiteListAddress = _whiteListAddr;
+    }
+
+    function setWhiteListId(uint _id) public onlyOwnerOrGov {
+        WhiteListId = _id;
+    }
+
     function WithdrawFee(address _token, address _to) external firewallProtected onlyOwnerOrGov {
-        require(Reserve[_token] > 0, "Fee amount is zero");
+        if (FeeReserve[_token] == 0) revert FeeAmountIsZero();
         if (_token == address(0)) {
-            payable(_to).transfer(Reserve[_token]);
+            (bool success, ) = _to.call{value: FeeReserve[_token]}("");
+            if (!success) revert TransferFailed();
         } else {
-            TransferToken(_token, _to, Reserve[_token]);
+            TransferToken(_token, _to, FeeReserve[_token]);
         }
-        Reserve[_token] = 0;
+        FeeReserve[_token] = 0;
     }
 }
diff --git a/contracts/mocks/FeeHelper.sol b/contracts/mocks/FeeHelper.sol
index 4c6aacb..9c12744 100644
--- a/contracts/mocks/FeeHelper.sol
+++ b/contracts/mocks/FeeHelper.sol
@@ -1,34 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../GovManager.sol";
 import "../FeeBaseHelper.sol";
 
-// example to use FeeBaseHelper
-contract FeeHelper is GovManager, ERC20Helper {
-    FeeBaseHelper public BaseFee;
+contract FeeHelper is FeeBaseHelper {
 
-    constructor() {
-        BaseFee = new FeeBaseHelper();
-    }
-
-    function PayFee() public payable {
-        if (BaseFee.FeeToken() != address(0)) {
-            TransferInToken(BaseFee.FeeToken(), msg.sender, BaseFee.Fee());
-            IERC20(BaseFee.FeeToken()).approve(address(BaseFee), BaseFee.Fee());
-        }
-        BaseFee.PayFee{value: msg.value}(BaseFee.Fee());
-    }
-
-    function WithdrawFee(address payable _to) public onlyOwnerOrGov {
-        BaseFee.WithdrawFee(BaseFee.FeeToken(), _to);
-    }
-
-    function SetFee(uint256 _amount) public onlyOwnerOrGov {
-        BaseFee.SetFeeAmount(_amount);
-    }
-
-    function SetToken(address _token) public onlyOwnerOrGov {
-        BaseFee.SetFeeToken(_token);
+    function MethodWithFee() public payable {
+        TakeFee();
     }
 }
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index deadd31..6381a9b 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -1,6 +1,6 @@
 import { ZERO_ADDRESS } from '../scripts/constants';
 import { deployed } from '../scripts/deploy';
-import { ERC20Token, FeeBaseHelper, FeeHelper } from '../typechain-types';
+import { ERC20Token, FeeHelper } from '../typechain-types';
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
 import { expect } from 'chai';
 import { ethers } from 'hardhat';
@@ -9,20 +9,18 @@ describe('Fee Helper Test', function () {
   const fee: number = 100000;
   let token: ERC20Token;
   let payer: SignerWithAddress, receiver: SignerWithAddress;
-  let feeHelper: FeeHelper, feeBase: FeeBaseHelper;
+  let feeHelper: FeeHelper;
 
   before(async () => {
     [payer, receiver] = await ethers.getSigners();
     feeHelper = await deployed('FeeHelper');
-    const FeeBaseHelper = await ethers.getContractFactory('FeeBaseHelper');
-    feeBase = await FeeBaseHelper.attach(await feeHelper.BaseFee());
     token = await deployed('ERC20Token', 'TEST token', 'TEST');
   });
 
   it('zero fee', async () => {
     const gasPrice = 2500000000;
     const oldBal = await payer.getBalance();
-    const tx = await feeHelper.connect(payer).PayFee({ gasPrice: gasPrice });
+    const tx = await feeHelper.connect(payer).MethodWithFee({ gasPrice: gasPrice });
     const txReceipt = await tx.wait();
     const actualBal = await payer.getBalance();
     const gas = txReceipt.gasUsed.mul(gasPrice);
@@ -32,24 +30,24 @@ describe('Fee Helper Test', function () {
 
   describe('test ERC20 token', async () => {
     it('should set fee token', async () => {
-      await feeHelper.SetFee(fee);
-      await feeHelper.SetToken(token.address);
-      const feeToken = await feeBase.FeeToken();
-      const actualFee = await feeBase.Fee();
+      await feeHelper.SetFeeAmount(fee);
+      await feeHelper.SetFeeToken(token.address);
+      const feeToken = await feeHelper.FeeToken();
+      const actualFee = await feeHelper.FeeAmount();
       expect(actualFee).to.be.equal(fee);
       expect(feeToken).to.be.equal(token.address);
     });
 
     it('should pay', async () => {
       await token.connect(payer).approve(feeHelper.address, fee);
-      const oldBal = await token.balanceOf(feeBase.address);
-      await feeHelper.connect(payer).PayFee();
-      const actualBal = await token.balanceOf(feeBase.address);
+      const oldBal = await token.balanceOf(feeHelper.address);
+      await feeHelper.connect(payer).MethodWithFee();
+      const actualBal = await token.balanceOf(feeHelper.address);
       expect(actualBal).to.be.equal(oldBal.add(fee));
     });
 
     it('should withdraw', async () => {
-      await feeHelper.WithdrawFee(payer.address);
+      await feeHelper.WithdrawFee(token.address, payer.address);
       const actualBal = await token.balanceOf(payer.address);
       expect(actualBal).to.be.equal(await token.totalSupply());
     });
@@ -57,23 +55,23 @@ describe('Fee Helper Test', function () {
 
   describe('test ETH coin', async () => {
     it('should set fee token', async () => {
-      await feeHelper.SetToken(ZERO_ADDRESS);
-      const feeToken = await feeBase.FeeToken();
-      const actualFee = await feeBase.Fee();
+      await feeHelper.SetFeeToken(ZERO_ADDRESS);
+      const feeToken = await feeHelper.FeeToken();
+      const actualFee = await feeHelper.FeeAmount();
       expect(actualFee).to.be.equal(fee);
       expect(feeToken).to.be.equal(ZERO_ADDRESS);
     });
 
     it('should pay', async () => {
-      const oldBal = await ethers.provider.getBalance(feeBase.address);
-      await feeHelper.connect(payer).PayFee({ value: fee });
-      const actualBal = await ethers.provider.getBalance(feeBase.address);
+      const oldBal = await ethers.provider.getBalance(feeHelper.address);
+      await feeHelper.connect(payer).MethodWithFee({ value: fee });
+      const actualBal = await ethers.provider.getBalance(feeHelper.address);
       expect(actualBal).to.be.equal(oldBal.add(fee));
     });
 
     it('should withdraw', async () => {
       const oldBal = await ethers.provider.getBalance(receiver.address);
-      await feeHelper.WithdrawFee(receiver.address);
+      await feeHelper.WithdrawFee(ZERO_ADDRESS, receiver.address);
       const actualBal = await ethers.provider.getBalance(receiver.address);
       expect(actualBal).to.be.equal(oldBal.add(fee));
     });

From abf83dc1fc3649771f9ecab8b6efc86ae32bceba Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Thu, 21 Mar 2024 16:57:50 +0530
Subject: [PATCH 03/16] minor fix

---
 contracts/FeeBaseHelper.sol | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index 1175996..9405fd3 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -29,11 +29,10 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
                 feeToPay -= credits;
                 IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, credits);
             } else {
-                feeToPay = 0;
                 IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, feeToPay);
+                return;
             }
         }
-        if( feeToPay == 0 ) return;
         if (FeeToken == address(0)) {
             if (msg.value < feeToPay) revert NotEnoughFeeProvided();
             emit TransferInETH(msg.value, msg.sender);

From 60b23989a036baebea1fceccf1cb15481ae2a346 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Thu, 21 Mar 2024 17:16:05 +0530
Subject: [PATCH 04/16] add private function _TakeFee

---
 contracts/FeeBaseHelper.sol | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index 9405fd3..461ad03 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -33,13 +33,18 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
                 return;
             }
         }
-        if (FeeToken == address(0)) {
-            if (msg.value < feeToPay) revert NotEnoughFeeProvided();
+        _TakeFee(feeToPay);
+    }
+
+    function _TakeFee(uint _fee) private {
+        address _feeToken = FeeToken;   // cache storage reads
+        if (_feeToken == address(0)) {
+            if (msg.value < _fee) revert NotEnoughFeeProvided();
             emit TransferInETH(msg.value, msg.sender);
         } else {
-            TransferInToken(FeeToken, msg.sender, feeToPay);
+            TransferInToken(_feeToken, msg.sender, _fee);
         }
-        FeeReserve[FeeToken] += feeToPay;
+        FeeReserve[_feeToken] += _fee;
     }
 
     function getCredits(address _user) public view returns(uint) {

From fa4f5abb67ff03839a5532b126dbe79e33e24993 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Fri, 22 Mar 2024 13:03:21 +0530
Subject: [PATCH 05/16] refactor and add test

---
 contracts/FeeBaseHelper.sol |  3 +--
 test/3_Fee.ts               | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index 461ad03..cfa0a08 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -25,11 +25,10 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
         if(feeToPay == 0) return;
         uint credits = getCredits(msg.sender);
         if(credits > 0) {
+            IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, credits < feeToPay ? credits : feeToPay);
             if(credits < feeToPay) {
                 feeToPay -= credits;
-                IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, credits);
             } else {
-                IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, feeToPay);
                 return;
             }
         }
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index 6381a9b..3635df6 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -76,4 +76,25 @@ describe('Fee Helper Test', function () {
       expect(actualBal).to.be.equal(oldBal.add(fee));
     });
   });
+
+  describe("Whitelist Settings", async () => {
+    it("should set whitelist address", async () => {
+      const oldWhiteList = await feeHelper.WhiteListAddress()
+      const newWhiteList = (await ethers.getSigners()).at(-1) as SignerWithAddress;
+      await feeHelper.setWhiteListAddress(newWhiteList.address)
+      const whiteList = await feeHelper.WhiteListAddress()
+      expect(whiteList).to.be.equal(newWhiteList.address)
+      expect(whiteList).to.not.equal(oldWhiteList)
+      await feeHelper.setWhiteListAddress(oldWhiteList)
+    })
+
+    it("should set whitelist id", async () => {
+      const oldWhiteListId = await feeHelper.WhiteListId()
+      const newwhiteListId = 5
+      await feeHelper.setWhiteListId(newwhiteListId)
+      const whiteListId = await feeHelper.WhiteListId()
+      expect(whiteListId).to.be.equal(newwhiteListId)
+      expect(whiteListId).to.not.equal(oldWhiteListId)
+    })
+  })
 });

From c2ca7f3057bd3c31f8af89a1a88f52930eab844e Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Fri, 22 Mar 2024 13:59:40 +0530
Subject: [PATCH 06/16] more tests

---
 contracts/mocks/WhiteListMock.sol | 23 ++++++++++
 test/3_Fee.ts                     | 76 ++++++++++++++++++++++++++++---
 2 files changed, 93 insertions(+), 6 deletions(-)
 create mode 100644 contracts/mocks/WhiteListMock.sol

diff --git a/contracts/mocks/WhiteListMock.sol b/contracts/mocks/WhiteListMock.sol
new file mode 100644
index 0000000..fb87234
--- /dev/null
+++ b/contracts/mocks/WhiteListMock.sol
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract WhiteListMock {
+    uint constant public WhiteListId = 1;
+
+    mapping (address => uint) public AddressToCredits;
+
+    function setCredits(address _user, uint _credits) external {
+        AddressToCredits[_user] = _credits;
+    }
+
+    function Check(address _user, uint _whiteListId) external view returns(uint) {
+        if(_whiteListId != WhiteListId) return 0;
+        return AddressToCredits[_user];
+    }
+
+    function Register(address _user, uint _whiteListId, uint _amount) external {
+        if(_whiteListId != WhiteListId) return;
+        AddressToCredits[_user] = AddressToCredits[_user] - _amount;
+    }
+
+}
\ No newline at end of file
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index 3635df6..b204225 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -1,20 +1,24 @@
+import { BigNumber } from '@ethersproject/bignumber';
 import { ZERO_ADDRESS } from '../scripts/constants';
 import { deployed } from '../scripts/deploy';
-import { ERC20Token, FeeHelper } from '../typechain-types';
+import { ERC20Token, FeeHelper, WhiteListMock } from '../typechain-types';
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
 import { expect } from 'chai';
 import { ethers } from 'hardhat';
+import exp from 'constants';
 
 describe('Fee Helper Test', function () {
   const fee: number = 100000;
   let token: ERC20Token;
   let payer: SignerWithAddress, receiver: SignerWithAddress;
   let feeHelper: FeeHelper;
+  let Whitelist: WhiteListMock;
 
   before(async () => {
     [payer, receiver] = await ethers.getSigners();
     feeHelper = await deployed('FeeHelper');
     token = await deployed('ERC20Token', 'TEST token', 'TEST');
+    Whitelist = await deployed('WhiteListMock');
   });
 
   it('zero fee', async () => {
@@ -69,6 +73,10 @@ describe('Fee Helper Test', function () {
       expect(actualBal).to.be.equal(oldBal.add(fee));
     });
 
+    it("should revert when fee is not paid", async () => {
+      await expect(feeHelper.connect(payer).MethodWithFee({value: fee / 2})).to.be.revertedWithCustomError(feeHelper, "NotEnoughFeeProvided");
+    })
+
     it('should withdraw', async () => {
       const oldBal = await ethers.provider.getBalance(receiver.address);
       await feeHelper.WithdrawFee(ZERO_ADDRESS, receiver.address);
@@ -78,23 +86,79 @@ describe('Fee Helper Test', function () {
   });
 
   describe("Whitelist Settings", async () => {
+
+    it("should get 0 credits when whitelistAddress is not set", async () => {
+      const credits = await feeHelper.getCredits(payer.address);
+      expect(credits).to.be.equal(0);
+    })
+
     it("should set whitelist address", async () => {
       const oldWhiteList = await feeHelper.WhiteListAddress()
-      const newWhiteList = (await ethers.getSigners()).at(-1) as SignerWithAddress;
-      await feeHelper.setWhiteListAddress(newWhiteList.address)
+      await feeHelper.setWhiteListAddress(Whitelist.address)
       const whiteList = await feeHelper.WhiteListAddress()
-      expect(whiteList).to.be.equal(newWhiteList.address)
+      expect(whiteList).to.be.equal(Whitelist.address)
       expect(whiteList).to.not.equal(oldWhiteList)
-      await feeHelper.setWhiteListAddress(oldWhiteList)
+    })
+
+    it("should get 0 credits when WhiteList is not set", async () => {
+      const whitelistAddress = await feeHelper.WhiteListAddress()
+      const credits = await feeHelper.getCredits(payer.address);
+      expect(whitelistAddress).to.be.equal(Whitelist.address)
+      expect(credits).to.be.equal(0);
     })
 
     it("should set whitelist id", async () => {
       const oldWhiteListId = await feeHelper.WhiteListId()
-      const newwhiteListId = 5
+      const newwhiteListId = 1
       await feeHelper.setWhiteListId(newwhiteListId)
       const whiteListId = await feeHelper.WhiteListId()
       expect(whiteListId).to.be.equal(newwhiteListId)
       expect(whiteListId).to.not.equal(oldWhiteListId)
     })
+
+    it("should return correct credits", async () => {
+      let credits: number = fee * 5;
+      await Whitelist.setCredits(payer.address, credits)
+      const _credits = await feeHelper.getCredits(payer.address);
+      expect(credits).to.be.equal(_credits);
+    })
+
+    it("should take full fee when user has not credits", async () => {
+      await feeHelper.SetFeeToken(token.address);
+      await Whitelist.setCredits(payer.address, 0)
+      const beforePayerBalance = await token.balanceOf(payer.address);
+      await token.connect(payer).approve(feeHelper.address, fee);
+      const tx = await feeHelper.connect(payer).MethodWithFee();
+      const afterPayerBalance = await token.balanceOf(payer.address);
+      expect(beforePayerBalance.sub(afterPayerBalance)).to.be.equal(fee);
+      expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      await expect(tx).to.emit(feeHelper, "TransferIn").withArgs(fee, payer.address, token.address);
+    })
+
+    it("should not take fee when user has credits", async () => {
+      await feeHelper.SetFeeToken(token.address);
+      const credits = fee * 5;
+      await Whitelist.setCredits(payer.address, credits)
+      const beforePayerBalance = await token.balanceOf(payer.address);
+      const tx = await feeHelper.connect(payer).MethodWithFee();
+      const afterPayerBalance = await token.balanceOf(payer.address);
+      expect(beforePayerBalance).to.be.equal(afterPayerBalance);
+      expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      await expect(tx).to.not.emit(feeHelper, "TransferIn");
+    })
+
+    it("should take partial fee when user has less credits than fee", async () => {
+      await feeHelper.SetFeeToken(token.address);
+      const credits = fee / 2;
+      await Whitelist.setCredits(payer.address, credits)
+      const beforePayerBalance = await token.balanceOf(payer.address);
+      await token.connect(payer).approve(feeHelper.address, fee - credits);
+      const tx = await feeHelper.connect(payer).MethodWithFee();
+      const afterPayerBalance = await token.balanceOf(payer.address);
+      expect(beforePayerBalance.sub(afterPayerBalance)).to.be.equal(fee - credits);
+      expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      await expect(tx).to.emit(feeHelper, "TransferIn").withArgs(fee - credits, payer.address, token.address);
+    })
+
   })
 });

From 3c41a5b87b01f8bfbee27f88954d355047f24321 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Fri, 22 Mar 2024 15:27:16 +0530
Subject: [PATCH 07/16] codefactor fix

---
 test/3_Fee.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index b204225..a22b2c4 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -117,7 +117,7 @@ describe('Fee Helper Test', function () {
     })
 
     it("should return correct credits", async () => {
-      let credits: number = fee * 5;
+      const credits: number = fee * 5;
       await Whitelist.setCredits(payer.address, credits)
       const _credits = await feeHelper.getCredits(payer.address);
       expect(credits).to.be.equal(_credits);

From 03f46461d23584763dde148781ff53c40a7f6f47 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Fri, 22 Mar 2024 20:00:14 +0530
Subject: [PATCH 08/16] merged setter functions

---
 contracts/FeeBaseHelper.sol | 14 +++-----------
 test/3_Fee.ts               | 19 +++++++++----------
 2 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/contracts/FeeBaseHelper.sol b/contracts/FeeBaseHelper.sol
index cfa0a08..9f5c1a5 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/FeeBaseHelper.sol
@@ -51,21 +51,13 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
         return IWhiteList(WhiteListAddress).Check(_user, WhiteListId);
     }
 
-    function SetFeeAmount(uint _amount) external firewallProtected onlyOwnerOrGov {
-        emit NewFeeAmount(_amount, FeeAmount);
+    function setFee(address _token, uint _amount) external firewallProtected onlyOwnerOrGov {
+        FeeToken = _token;
         FeeAmount = _amount;
     }
 
-    function SetFeeToken(address _token) external firewallProtected onlyOwnerOrGov {
-        emit NewFeeToken(_token, FeeToken);
-        FeeToken = _token; // set address(0) to use ETH/BNB as main coin
-    }
-
-    function setWhiteListAddress(address _whiteListAddr) public onlyOwnerOrGov {
+    function setWhiteList(address _whiteListAddr, uint _id) external firewallProtected onlyOwnerOrGov {
         WhiteListAddress = _whiteListAddr;
-    }
-
-    function setWhiteListId(uint _id) public onlyOwnerOrGov {
         WhiteListId = _id;
     }
 
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index a22b2c4..55db19f 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -33,9 +33,8 @@ describe('Fee Helper Test', function () {
   });
 
   describe('test ERC20 token', async () => {
-    it('should set fee token', async () => {
-      await feeHelper.SetFeeAmount(fee);
-      await feeHelper.SetFeeToken(token.address);
+    it('should set fee token and amount', async () => {
+      await feeHelper.setFee(token.address, fee);
       const feeToken = await feeHelper.FeeToken();
       const actualFee = await feeHelper.FeeAmount();
       expect(actualFee).to.be.equal(fee);
@@ -58,8 +57,8 @@ describe('Fee Helper Test', function () {
   });
 
   describe('test ETH coin', async () => {
-    it('should set fee token', async () => {
-      await feeHelper.SetFeeToken(ZERO_ADDRESS);
+    it('should set fee token and amount', async () => {
+      await feeHelper.setFee(ZERO_ADDRESS, fee);
       const feeToken = await feeHelper.FeeToken();
       const actualFee = await feeHelper.FeeAmount();
       expect(actualFee).to.be.equal(fee);
@@ -94,7 +93,7 @@ describe('Fee Helper Test', function () {
 
     it("should set whitelist address", async () => {
       const oldWhiteList = await feeHelper.WhiteListAddress()
-      await feeHelper.setWhiteListAddress(Whitelist.address)
+      await feeHelper.setWhiteList(Whitelist.address, 0)
       const whiteList = await feeHelper.WhiteListAddress()
       expect(whiteList).to.be.equal(Whitelist.address)
       expect(whiteList).to.not.equal(oldWhiteList)
@@ -110,7 +109,7 @@ describe('Fee Helper Test', function () {
     it("should set whitelist id", async () => {
       const oldWhiteListId = await feeHelper.WhiteListId()
       const newwhiteListId = 1
-      await feeHelper.setWhiteListId(newwhiteListId)
+      await feeHelper.setWhiteList(Whitelist.address, newwhiteListId)
       const whiteListId = await feeHelper.WhiteListId()
       expect(whiteListId).to.be.equal(newwhiteListId)
       expect(whiteListId).to.not.equal(oldWhiteListId)
@@ -124,7 +123,7 @@ describe('Fee Helper Test', function () {
     })
 
     it("should take full fee when user has not credits", async () => {
-      await feeHelper.SetFeeToken(token.address);
+      await feeHelper.setFee(token.address, fee);
       await Whitelist.setCredits(payer.address, 0)
       const beforePayerBalance = await token.balanceOf(payer.address);
       await token.connect(payer).approve(feeHelper.address, fee);
@@ -136,7 +135,7 @@ describe('Fee Helper Test', function () {
     })
 
     it("should not take fee when user has credits", async () => {
-      await feeHelper.SetFeeToken(token.address);
+      await feeHelper.setFee(token.address, fee);
       const credits = fee * 5;
       await Whitelist.setCredits(payer.address, credits)
       const beforePayerBalance = await token.balanceOf(payer.address);
@@ -148,7 +147,7 @@ describe('Fee Helper Test', function () {
     })
 
     it("should take partial fee when user has less credits than fee", async () => {
-      await feeHelper.SetFeeToken(token.address);
+      await feeHelper.setFee(token.address, fee);
       const credits = fee / 2;
       await Whitelist.setCredits(payer.address, credits)
       const beforePayerBalance = await token.balanceOf(payer.address);

From 472977fa418f378d9e3ef90eeaee1f0409ad89c6 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Sun, 24 Mar 2024 15:27:09 +0530
Subject: [PATCH 09/16] npm version update

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 8a74c8f..8c658f6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@poolzfinance/poolz-helper-v2",
-  "version": "2.3.5",
+  "version": "2.4.0",
   "description": "A single source of truth of helper contracts used by Poolz.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

From 900352c1dfa1635b83d26ef9e06ce794f0c98c74 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Mon, 25 Mar 2024 17:59:21 +0530
Subject: [PATCH 10/16] whitelist and fee experiment (#99)

* whitelist and fee experiment

* refactor
---
 contracts/{ => Fee}/FeeBaseHelper.sol | 22 ++++-----------
 contracts/Fee/WhiteListHelper.sol     | 39 +++++++++++++++++++++++++++
 contracts/interfaces/IWhiteList.sol   |  2 ++
 contracts/mocks/FeeHelper.sol         |  2 +-
 4 files changed, 47 insertions(+), 18 deletions(-)
 rename contracts/{ => Fee}/FeeBaseHelper.sol (71%)
 create mode 100644 contracts/Fee/WhiteListHelper.sol

diff --git a/contracts/FeeBaseHelper.sol b/contracts/Fee/FeeBaseHelper.sol
similarity index 71%
rename from contracts/FeeBaseHelper.sol
rename to contracts/Fee/FeeBaseHelper.sol
index 9f5c1a5..f1a9041 100644
--- a/contracts/FeeBaseHelper.sol
+++ b/contracts/Fee/FeeBaseHelper.sol
@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./ERC20Helper.sol";
-import "./GovManager.sol";
-import "./interfaces/IWhiteList.sol";
+import "../ERC20Helper.sol";
+import "./WhiteListHelper.sol";
 
-abstract contract FeeBaseHelper is ERC20Helper, GovManager {
+abstract contract FeeBaseHelper is ERC20Helper, WhiteListHelper {
     event TransferInETH(uint Amount, address From);
     event NewFeeAmount(uint NewFeeAmount, uint OldFeeAmount);
     event NewFeeToken(address NewFeeToken, address OldFeeToken);
@@ -15,9 +14,8 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
     error TransferFailed();
 
     uint public FeeAmount;
-    uint public WhiteListId;
     address public FeeToken;
-    address public WhiteListAddress;
+    
     mapping(address => uint) public FeeReserve;
 
     function TakeFee() internal virtual firewallProtected {
@@ -25,7 +23,7 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
         if(feeToPay == 0) return;
         uint credits = getCredits(msg.sender);
         if(credits > 0) {
-            IWhiteList(WhiteListAddress).Register(msg.sender, WhiteListId, credits < feeToPay ? credits : feeToPay);
+            _whiteListRegister(msg.sender, credits < feeToPay ? credits : feeToPay);
             if(credits < feeToPay) {
                 feeToPay -= credits;
             } else {
@@ -46,21 +44,11 @@ abstract contract FeeBaseHelper is ERC20Helper, GovManager {
         FeeReserve[_feeToken] += _fee;
     }
 
-    function getCredits(address _user) public view returns(uint) {
-        if(WhiteListAddress == address(0) || WhiteListId == 0) return 0;
-        return IWhiteList(WhiteListAddress).Check(_user, WhiteListId);
-    }
-
     function setFee(address _token, uint _amount) external firewallProtected onlyOwnerOrGov {
         FeeToken = _token;
         FeeAmount = _amount;
     }
 
-    function setWhiteList(address _whiteListAddr, uint _id) external firewallProtected onlyOwnerOrGov {
-        WhiteListAddress = _whiteListAddr;
-        WhiteListId = _id;
-    }
-
     function WithdrawFee(address _token, address _to) external firewallProtected onlyOwnerOrGov {
         if (FeeReserve[_token] == 0) revert FeeAmountIsZero();
         if (_token == address(0)) {
diff --git a/contracts/Fee/WhiteListHelper.sol b/contracts/Fee/WhiteListHelper.sol
new file mode 100644
index 0000000..2646183
--- /dev/null
+++ b/contracts/Fee/WhiteListHelper.sol
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../interfaces/IWhiteList.sol";
+import "../GovManager.sol";
+
+abstract contract WhiteListHelper is GovManager {
+    error WhiteListNotSet();
+
+    uint public WhiteListId;
+    address public WhiteListAddress;
+
+    modifier WhiteListSet {
+        if(WhiteListAddress == address(0) || WhiteListId == 0) revert WhiteListNotSet();
+        _;
+    }
+
+    function getCredits(address _user) public view returns(uint) {
+        if(WhiteListAddress == address(0) || WhiteListId == 0) return 0;
+        return IWhiteList(WhiteListAddress).Check(_user, WhiteListId);
+    }
+
+    function setupNewWhitelist(address _whiteListAddress) external firewallProtected onlyOwnerOrGov {
+        WhiteListAddress = _whiteListAddress;
+        WhiteListId = IWhiteList(_whiteListAddress).CreateManualWhiteList(type(uint256).max, address(this));
+    }
+
+    function addUsers(address[] calldata _users, uint256[] calldata _credits) external firewallProtected onlyOwnerOrGov WhiteListSet {        
+        IWhiteList(WhiteListAddress).AddAddress(WhiteListId, _users, _credits);
+    }
+
+    function removeUsers(address[] calldata _users) external firewallProtected onlyOwnerOrGov WhiteListSet {
+        IWhiteList(WhiteListAddress).RemoveAddress(WhiteListId, _users);
+    }
+
+    function _whiteListRegister(address _user, uint _credits) internal {
+        IWhiteList(WhiteListAddress).Register(_user, WhiteListId, _credits);
+    }
+}
\ No newline at end of file
diff --git a/contracts/interfaces/IWhiteList.sol b/contracts/interfaces/IWhiteList.sol
index 665ec2b..bce591d 100644
--- a/contracts/interfaces/IWhiteList.sol
+++ b/contracts/interfaces/IWhiteList.sol
@@ -9,4 +9,6 @@ interface IWhiteList {
     function LastRoundRegister(address _Subject,uint256 _Id) external;
     function CreateManualWhiteList(uint256 _ChangeUntil, address _Contract) external payable returns(uint256 Id);
     function ChangeCreator(uint256 _Id, address _NewCreator) external;
+    function AddAddress(uint256 _Id, address[] calldata _Users, uint256[] calldata _Amount) external;
+    function RemoveAddress(uint256 _Id, address[] calldata _Users) external;
 }
diff --git a/contracts/mocks/FeeHelper.sol b/contracts/mocks/FeeHelper.sol
index 9c12744..cfb7e44 100644
--- a/contracts/mocks/FeeHelper.sol
+++ b/contracts/mocks/FeeHelper.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../FeeBaseHelper.sol";
+import "../Fee/FeeBaseHelper.sol";
 
 contract FeeHelper is FeeBaseHelper {
 

From ca893c440520ba8f88156c260a0240ba481a6e10 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Mon, 25 Mar 2024 18:53:16 +0530
Subject: [PATCH 11/16] tests updated

---
 contracts/mocks/WhiteListMock.sol | 26 ++++++++++++++++++++----
 test/3_Fee.ts                     | 33 +++++++++++--------------------
 2 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/contracts/mocks/WhiteListMock.sol b/contracts/mocks/WhiteListMock.sol
index fb87234..1bb6d73 100644
--- a/contracts/mocks/WhiteListMock.sol
+++ b/contracts/mocks/WhiteListMock.sol
@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-contract WhiteListMock {
-    uint constant public WhiteListId = 1;
+import "../interfaces/IWhiteList.sol";
+
+contract WhiteListMock is IWhiteList {
+    uint public WhiteListId;
 
     mapping (address => uint) public AddressToCredits;
 
-    function setCredits(address _user, uint _credits) external {
-        AddressToCredits[_user] = _credits;
+    function CreateManualWhiteList(uint, address) external payable returns(uint) {
+        return ++WhiteListId;
     }
 
     function Check(address _user, uint _whiteListId) external view returns(uint) {
@@ -20,4 +22,20 @@ contract WhiteListMock {
         AddressToCredits[_user] = AddressToCredits[_user] - _amount;
     }
 
+    function AddAddress(uint256 , address[] calldata _Users, uint256[] calldata _Amount) external{
+        for(uint i = 0; i < _Users.length; i++){
+            AddressToCredits[_Users[i]] = _Amount[i];
+        }
+    }
+
+    function RemoveAddress(uint256 , address[] calldata _Users) external{
+        for(uint i = 0; i < _Users.length; i++){
+            delete AddressToCredits[_Users[i]];
+        }
+    }
+
+    // to avoid the error: Contract "WhiteListMock" should be marked as abstract
+    function LastRoundRegister(address _Subject,uint256 _Id) external {}
+    function ChangeCreator(uint256 _Id, address _NewCreator) external {}
+
 }
\ No newline at end of file
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index 55db19f..66110f0 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -93,38 +93,27 @@ describe('Fee Helper Test', function () {
 
     it("should set whitelist address", async () => {
       const oldWhiteList = await feeHelper.WhiteListAddress()
-      await feeHelper.setWhiteList(Whitelist.address, 0)
+      await feeHelper.setupNewWhitelist(Whitelist.address)
       const whiteList = await feeHelper.WhiteListAddress()
+      const whiteListId = await feeHelper.WhiteListId()
       expect(whiteList).to.be.equal(Whitelist.address)
       expect(whiteList).to.not.equal(oldWhiteList)
+      expect(whiteListId).to.be.equal(1)
     })
 
-    it("should get 0 credits when WhiteList is not set", async () => {
-      const whitelistAddress = await feeHelper.WhiteListAddress()
-      const credits = await feeHelper.getCredits(payer.address);
-      expect(whitelistAddress).to.be.equal(Whitelist.address)
-      expect(credits).to.be.equal(0);
-    })
-
-    it("should set whitelist id", async () => {
-      const oldWhiteListId = await feeHelper.WhiteListId()
-      const newwhiteListId = 1
-      await feeHelper.setWhiteList(Whitelist.address, newwhiteListId)
-      const whiteListId = await feeHelper.WhiteListId()
-      expect(whiteListId).to.be.equal(newwhiteListId)
-      expect(whiteListId).to.not.equal(oldWhiteListId)
-    })
-
-    it("should return correct credits", async () => {
+    it("should add and remove new users", async () => {
       const credits: number = fee * 5;
-      await Whitelist.setCredits(payer.address, credits)
+      await feeHelper.addUsers([payer.address], [credits])
       const _credits = await feeHelper.getCredits(payer.address);
       expect(credits).to.be.equal(_credits);
+      await feeHelper.removeUsers([payer.address])
+      const _credits2 = await feeHelper.getCredits(payer.address);
+      expect(0).to.be.equal(_credits2);
     })
 
     it("should take full fee when user has not credits", async () => {
       await feeHelper.setFee(token.address, fee);
-      await Whitelist.setCredits(payer.address, 0)
+      await feeHelper.addUsers([payer.address], [0])
       const beforePayerBalance = await token.balanceOf(payer.address);
       await token.connect(payer).approve(feeHelper.address, fee);
       const tx = await feeHelper.connect(payer).MethodWithFee();
@@ -137,7 +126,7 @@ describe('Fee Helper Test', function () {
     it("should not take fee when user has credits", async () => {
       await feeHelper.setFee(token.address, fee);
       const credits = fee * 5;
-      await Whitelist.setCredits(payer.address, credits)
+      await feeHelper.addUsers([payer.address], [credits])
       const beforePayerBalance = await token.balanceOf(payer.address);
       const tx = await feeHelper.connect(payer).MethodWithFee();
       const afterPayerBalance = await token.balanceOf(payer.address);
@@ -149,7 +138,7 @@ describe('Fee Helper Test', function () {
     it("should take partial fee when user has less credits than fee", async () => {
       await feeHelper.setFee(token.address, fee);
       const credits = fee / 2;
-      await Whitelist.setCredits(payer.address, credits)
+      await feeHelper.addUsers([payer.address], [credits])
       const beforePayerBalance = await token.balanceOf(payer.address);
       await token.connect(payer).approve(feeHelper.address, fee - credits);
       const tx = await feeHelper.connect(payer).MethodWithFee();

From eedd0136da778ed45641cb6308aa365a26debe59 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Mon, 25 Mar 2024 19:04:53 +0530
Subject: [PATCH 12/16] returning fee amount

---
 contracts/Fee/FeeBaseHelper.sol |  8 ++++----
 contracts/mocks/FeeHelper.sol   |  4 ++--
 test/3_Fee.ts                   | 12 ++++++++++++
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/contracts/Fee/FeeBaseHelper.sol b/contracts/Fee/FeeBaseHelper.sol
index f1a9041..bff12f6 100644
--- a/contracts/Fee/FeeBaseHelper.sol
+++ b/contracts/Fee/FeeBaseHelper.sol
@@ -18,16 +18,16 @@ abstract contract FeeBaseHelper is ERC20Helper, WhiteListHelper {
     
     mapping(address => uint) public FeeReserve;
 
-    function TakeFee() internal virtual firewallProtected {
-        uint feeToPay = FeeAmount;
-        if(feeToPay == 0) return;
+    function TakeFee() internal virtual firewallProtected returns(uint feeToPay){
+        feeToPay = FeeAmount;
+        if(feeToPay == 0) return 0;
         uint credits = getCredits(msg.sender);
         if(credits > 0) {
             _whiteListRegister(msg.sender, credits < feeToPay ? credits : feeToPay);
             if(credits < feeToPay) {
                 feeToPay -= credits;
             } else {
-                return;
+                return 0;
             }
         }
         _TakeFee(feeToPay);
diff --git a/contracts/mocks/FeeHelper.sol b/contracts/mocks/FeeHelper.sol
index cfb7e44..8de5b5f 100644
--- a/contracts/mocks/FeeHelper.sol
+++ b/contracts/mocks/FeeHelper.sol
@@ -5,7 +5,7 @@ import "../Fee/FeeBaseHelper.sol";
 
 contract FeeHelper is FeeBaseHelper {
 
-    function MethodWithFee() public payable {
-        TakeFee();
+    function MethodWithFee() public payable returns(uint){
+        return TakeFee();
     }
 }
diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index 66110f0..c33bc77 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -24,12 +24,14 @@ describe('Fee Helper Test', function () {
   it('zero fee', async () => {
     const gasPrice = 2500000000;
     const oldBal = await payer.getBalance();
+    const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee({ gasPrice: gasPrice });
     const tx = await feeHelper.connect(payer).MethodWithFee({ gasPrice: gasPrice });
     const txReceipt = await tx.wait();
     const actualBal = await payer.getBalance();
     const gas = txReceipt.gasUsed.mul(gasPrice);
     const expectedBal = oldBal.sub(gas);
     expect(actualBal).to.be.equal(expectedBal);
+    expect(feePaid).to.be.equal(0);
   });
 
   describe('test ERC20 token', async () => {
@@ -44,9 +46,11 @@ describe('Fee Helper Test', function () {
     it('should pay', async () => {
       await token.connect(payer).approve(feeHelper.address, fee);
       const oldBal = await token.balanceOf(feeHelper.address);
+      const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee();
       await feeHelper.connect(payer).MethodWithFee();
       const actualBal = await token.balanceOf(feeHelper.address);
       expect(actualBal).to.be.equal(oldBal.add(fee));
+      expect(feePaid).to.be.equal(fee);
     });
 
     it('should withdraw', async () => {
@@ -67,9 +71,11 @@ describe('Fee Helper Test', function () {
 
     it('should pay', async () => {
       const oldBal = await ethers.provider.getBalance(feeHelper.address);
+      const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee({ value: fee });
       await feeHelper.connect(payer).MethodWithFee({ value: fee });
       const actualBal = await ethers.provider.getBalance(feeHelper.address);
       expect(actualBal).to.be.equal(oldBal.add(fee));
+      expect(feePaid).to.be.equal(fee);
     });
 
     it("should revert when fee is not paid", async () => {
@@ -116,10 +122,12 @@ describe('Fee Helper Test', function () {
       await feeHelper.addUsers([payer.address], [0])
       const beforePayerBalance = await token.balanceOf(payer.address);
       await token.connect(payer).approve(feeHelper.address, fee);
+      const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee();
       const tx = await feeHelper.connect(payer).MethodWithFee();
       const afterPayerBalance = await token.balanceOf(payer.address);
       expect(beforePayerBalance.sub(afterPayerBalance)).to.be.equal(fee);
       expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      expect(feePaid).to.be.equal(fee);
       await expect(tx).to.emit(feeHelper, "TransferIn").withArgs(fee, payer.address, token.address);
     })
 
@@ -128,10 +136,12 @@ describe('Fee Helper Test', function () {
       const credits = fee * 5;
       await feeHelper.addUsers([payer.address], [credits])
       const beforePayerBalance = await token.balanceOf(payer.address);
+      const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee();
       const tx = await feeHelper.connect(payer).MethodWithFee();
       const afterPayerBalance = await token.balanceOf(payer.address);
       expect(beforePayerBalance).to.be.equal(afterPayerBalance);
       expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      expect(feePaid).to.be.equal(0);
       await expect(tx).to.not.emit(feeHelper, "TransferIn");
     })
 
@@ -141,10 +151,12 @@ describe('Fee Helper Test', function () {
       await feeHelper.addUsers([payer.address], [credits])
       const beforePayerBalance = await token.balanceOf(payer.address);
       await token.connect(payer).approve(feeHelper.address, fee - credits);
+      const feePaid = await feeHelper.connect(payer).callStatic.MethodWithFee();
       const tx = await feeHelper.connect(payer).MethodWithFee();
       const afterPayerBalance = await token.balanceOf(payer.address);
       expect(beforePayerBalance.sub(afterPayerBalance)).to.be.equal(fee - credits);
       expect(await feeHelper.FeeToken()).to.be.equal(token.address);
+      expect(feePaid).to.be.equal(fee - credits);
       await expect(tx).to.emit(feeHelper, "TransferIn").withArgs(fee - credits, payer.address, token.address);
     })
 

From 71d94e7bee6030c4fb61bb72464368eff25d132f Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Mon, 25 Mar 2024 19:05:35 +0530
Subject: [PATCH 13/16] npm version update

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 8c658f6..5c6f26c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@poolzfinance/poolz-helper-v2",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "A single source of truth of helper contracts used by Poolz.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

From c9cd2cbbaa2d58f9b116e3c8d9209579013c100f Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Tue, 16 Apr 2024 15:19:47 +0530
Subject: [PATCH 14/16] fixed reentrancy

---
 contracts/Fee/FeeBaseHelper.sol | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/contracts/Fee/FeeBaseHelper.sol b/contracts/Fee/FeeBaseHelper.sol
index bff12f6..8e4af40 100644
--- a/contracts/Fee/FeeBaseHelper.sol
+++ b/contracts/Fee/FeeBaseHelper.sol
@@ -51,12 +51,13 @@ abstract contract FeeBaseHelper is ERC20Helper, WhiteListHelper {
 
     function WithdrawFee(address _token, address _to) external firewallProtected onlyOwnerOrGov {
         if (FeeReserve[_token] == 0) revert FeeAmountIsZero();
+        uint feeAmount = FeeReserve[_token];
+        FeeReserve[_token] = 0;
         if (_token == address(0)) {
-            (bool success, ) = _to.call{value: FeeReserve[_token]}("");
+            (bool success, ) = _to.call{value: feeAmount}("");
             if (!success) revert TransferFailed();
         } else {
-            TransferToken(_token, _to, FeeReserve[_token]);
+            TransferToken(_token, _to, feeAmount);
         }
-        FeeReserve[_token] = 0;
     }
 }

From e48697c6c56017489e17c26eb67789ec24ebb939 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Tue, 16 Apr 2024 15:21:17 +0530
Subject: [PATCH 15/16] 2.4.2

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9dec2ff..43beefb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@poolzfinance/poolz-helper-v2",
-  "version": "2.3.5",
+  "version": "2.4.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@poolzfinance/poolz-helper-v2",
-      "version": "2.3.5",
+      "version": "2.4.2",
       "license": "MIT",
       "dependencies": {
         "@ethersproject/bignumber": "^5.7.0",
diff --git a/package.json b/package.json
index 5c6f26c..62bc374 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@poolzfinance/poolz-helper-v2",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "A single source of truth of helper contracts used by Poolz.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

From 816a620f18aeaa04236c3b97bb6dcf0773278ae9 Mon Sep 17 00:00:00 2001
From: Ashwin Arora <ashwinarora48@gmail.com>
Date: Fri, 19 Apr 2024 15:02:11 +0530
Subject: [PATCH 16/16] sonar cloud fix

---
 test/3_Fee.ts | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/3_Fee.ts b/test/3_Fee.ts
index c33bc77..b806a23 100644
--- a/test/3_Fee.ts
+++ b/test/3_Fee.ts
@@ -1,11 +1,9 @@
-import { BigNumber } from '@ethersproject/bignumber';
 import { ZERO_ADDRESS } from '../scripts/constants';
 import { deployed } from '../scripts/deploy';
 import { ERC20Token, FeeHelper, WhiteListMock } from '../typechain-types';
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
 import { expect } from 'chai';
 import { ethers } from 'hardhat';
-import exp from 'constants';
 
 describe('Fee Helper Test', function () {
   const fee: number = 100000;