diff --git a/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js b/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
new file mode 100644
index 000000000..17234c8cf
--- /dev/null
+++ b/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
@@ -0,0 +1,134 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// When running the script with `hardhat run <script>` you'll find the Hardhat
+// Runtime Environment's members available in the global scope.
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+
+async function main() {
+  const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+  const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+  const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+
+  const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+  const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+
+  const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+
+  await hre.network.provider.request({
+    method: "evm_unlockUnknownAccount",
+    params: [governanceAddr],
+  });
+
+  const governanceSigner = ethers.provider.getSigner(governanceAddr);
+  const userSigner = ethers.provider.getSigner(userAddr);
+  const masterChef = await ethers.getContractAt(
+    "src/yield-farming/masterchef.sol:MasterChef",
+    masterChefAddr,
+    governanceSigner
+  );
+  masterChef.connect(governanceSigner);
+
+  /** *************************************setting up gauge proxy****************************************** */
+
+  // const blockNumBefore = await ethers.provider.getBlockNumber();
+  // const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+  // const timestampBefore = blockBefore.timestamp;
+
+  // console.log(Math.round(new Date().getTime()/1000));
+  // console.log(timestampBefore);
+
+  console.log("-- Deploying GaugeProxy v2 contract --");
+  const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+  console.log("Deploying GaugeProxyV2...");
+  const GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
+    initializer: "initialize",
+  });
+  await GaugeProxyV2.deployed();
+  console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+  const mDILLAddr = await GaugeProxyV2.TOKEN();
+
+  console.log("-- Adding mDILL to MasterChef --");
+  let populatedTx;
+  populatedTx = await masterChef.populateTransaction.add(
+    5000000,
+    mDILLAddr,
+    false
+    // { gasLimit: 9000000 }
+  );
+  await governanceSigner.sendTransaction(populatedTx);
+
+  /** *************************************add gauges****************************************** */
+
+  console.log("-- Adding PICKLE LP Gauge --");
+  await GaugeProxyV2.addGauge(pickleLP);
+
+  console.log("-- Adding pyveCRVETH Gauge --");
+  await GaugeProxyV2.addGauge(pyveCRVETH);
+
+  await hre.network.provider.request({
+    method: "evm_unlockUnknownAccount",
+    params: [userAddr],
+  });
+  // await GaugeProxyV2.updateCurrentId();
+  console.log("currentId ", (await GaugeProxyV2.currentId()).toString());
+
+  // console.log("first period time stamp ", (await GaugeProxyV2.firstDistribution()).toString());
+
+  /** ************************************* VOTING ****************************************** */
+
+  console.log("-- Voting on LP Gauge with 100% weight --");
+  const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+  populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+    gasLimit: 9000000,
+  });
+  await userSigner.sendTransaction(populatedTx);
+  console.log("voted");
+  const pidDill = (await masterChef.poolLength()) - 1;
+  await GaugeProxyV2.setPID(pidDill);
+  await GaugeProxyV2.deposit();
+
+  /** ************************************* increase time by 7 days ****************************************** */
+  console.log("-- Wait 7 days to accumulate");
+  await hre.network.provider.request({
+    method: "evm_increaseTime",
+    params: [3600 * 24 * 7],
+  });
+
+  /** ************************************* mine block ****************************************** */
+  console.log("-- Wait for 1 block to be mined --");
+  await hre.network.provider.request({
+    method: "evm_mine",
+  });
+
+  /** ************************************* DISTRIBUTE ****************************************** */
+  await GaugeProxyV2.updateCurrentId();
+  console.log("currentId", (await GaugeProxyV2.currentId()).toString());
+  console.log("-- Distribute PICKLE to gauges --");
+  await GaugeProxyV2.distribute(0, 2);
+
+  /** ************************************* get gauge address ****************************************** */
+
+  const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+  const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+  /** *************************************get PICKLE contract ****************************************** */
+  const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+  /** *************************************check rewards ****************************************** */
+  let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+  console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+  let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+  console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
new file mode 100644
index 000000000..993373ed8
--- /dev/null
+++ b/src/dill/gauge-middleware.sol
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {GaugeV2, Initializable, ProtocolGovernance, VirtualGaugeV2} from "./gauge-proxy-v2.sol";
+
+contract GaugeMiddleware is ProtocolGovernance, Initializable {
+    address public gaugeProxy;
+
+    function initialize(address _gaugeProxy, address _governance)
+        public
+        initializer
+    {
+        require(
+            _gaugeProxy != address(0),
+            "_gaugeProxy address cannot be set to zero"
+        );
+        require(
+            _governance != _gaugeProxy,
+            "_governance address and _gaugeProxy cannot be same"
+        );
+        gaugeProxy = _gaugeProxy;
+        governance = _governance;
+    }
+
+    function changeGaugeProxy(address _newgaugeProxy) external {
+        require(msg.sender == governance, "can only be called by governance");
+        gaugeProxy = _newgaugeProxy;
+    }
+
+    function addGauge(
+        address _token,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) external returns (address) {
+        require(msg.sender == gaugeProxy, "can only be called by gaugeProxy");
+        require(_token != address(0), "address of token cannot be zero");
+        return
+            address(
+                new GaugeV2(
+                    _token,
+                    _governance,
+                    msg.sender,
+                    _rewardSymbols,
+                    _rewardTokens
+                )
+            );
+    }
+}
+
+contract VirtualGaugeMiddleware is ProtocolGovernance, Initializable {
+    address public gaugeProxy;
+
+    function initialize(address _gaugeProxy, address _governance)
+        public
+        initializer
+    {
+        require(
+            _gaugeProxy != address(0),
+            "_gaugeProxy address cannot be set to zero"
+        );
+        require(
+            _governance != _gaugeProxy,
+            "_governance address and _gaugeProxy cannot be same"
+        );
+        gaugeProxy = _gaugeProxy;
+        governance = _governance;
+    }
+
+    function changeGaugeProxy(address _newgaugeProxy) external {
+        require(msg.sender == governance, "can only be called by governance");
+        gaugeProxy = _newgaugeProxy;
+    }
+
+    function addVirtualGauge(
+        address _jar,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) external returns (address) {
+        require(msg.sender == gaugeProxy, "can only be called by gaugeProxy");
+        require(_jar != address(0), "address of jar cannot be zero");
+        require(
+            _governance != address(0),
+            "address of governance cannot be zero"
+        );
+        return
+            address(
+                new VirtualGaugeV2(
+                    _jar,
+                    _governance,
+                    msg.sender,
+                    _rewardSymbols,
+                    _rewardTokens
+                )
+            );
+    }
+}
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
new file mode 100644
index 000000000..af6a7cc5f
--- /dev/null
+++ b/src/dill/gauge-proxy-v2.sol
@@ -0,0 +1,2161 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+library Address {
+    function isContract(address account) internal view returns (bool) {
+        bytes32 codehash;
+        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            codehash := extcodehash(account)
+        }
+        return (codehash != 0x0 && codehash != accountHash);
+    }
+
+    function toPayable(address account)
+        internal
+        pure
+        returns (address payable)
+    {
+        // return address(uint160(account));
+        return payable(address(uint160(account)));
+    }
+
+    function sendValue(address payable recipient, uint256 amount) internal {
+        require(
+            address(this).balance >= amount,
+            "Address: insufficient balance"
+        );
+
+        // solhint-disable-next-line avoid-call-value
+        (bool success, ) = recipient.call{value: amount}("");
+        require(
+            success,
+            "Address: unable to send value, recipient may have reverted"
+        );
+    }
+}
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount)
+        external
+        returns (bool);
+
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+}
+
+interface IGaugeMiddleware {
+    function addGauge(
+        address _token,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) external returns (address);
+}
+
+interface IVirtualGaugeMiddleware {
+    function addVirtualGauge(
+        address _jar,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) external returns (address);
+}
+
+library SafeERC20 {
+    using Address for address;
+
+    function safeTransfer(
+        IERC20 token,
+        address to,
+        uint256 value
+    ) internal {
+        callOptionalReturn(
+            token,
+            abi.encodeWithSelector(token.transfer.selector, to, value)
+        );
+    }
+
+    function safeTransferFrom(
+        IERC20 token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        callOptionalReturn(
+            token,
+            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
+        );
+    }
+
+    function safeApprove(
+        IERC20 token,
+        address spender,
+        uint256 value
+    ) internal {
+        require(
+            (value == 0) || (token.allowance(address(this), spender) == 0),
+            "SafeERC20: approve from non-zero to non-zero allowance"
+        );
+        callOptionalReturn(
+            token,
+            abi.encodeWithSelector(token.approve.selector, spender, value)
+        );
+    }
+
+    function safeIncreaseAllowance(
+        IERC20 token,
+        address spender,
+        uint256 value
+    ) internal {
+        uint256 newAllowance = token.allowance(address(this), spender) +
+            (value);
+        callOptionalReturn(
+            token,
+            abi.encodeWithSelector(
+                token.approve.selector,
+                spender,
+                newAllowance
+            )
+        );
+    }
+
+    function safeDecreaseAllowance(
+        IERC20 token,
+        address spender,
+        uint256 value
+    ) internal {
+        uint256 newAllowance = token.allowance(address(this), spender) - value;
+        callOptionalReturn(
+            token,
+            abi.encodeWithSelector(
+                token.approve.selector,
+                spender,
+                newAllowance
+            )
+        );
+    }
+
+    function callOptionalReturn(IERC20 token, bytes memory data) private {
+        require(address(token).isContract(), "SafeERC20: call to non-contract");
+
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory returndata) = address(token).call(data);
+        require(success, "SafeERC20: low-level call failed");
+
+        if (returndata.length > 0) {
+            // Return data is optional
+            // solhint-disable-next-line max-line-length
+            require(
+                abi.decode(returndata, (bool)),
+                "SafeERC20: ERC20 operation did not succeed"
+            );
+        }
+    }
+}
+
+library Math {
+    /**
+     * @dev Returns the largest of two numbers.
+     */
+    function max(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a >= b ? a : b;
+    }
+
+    /**
+     * @dev Returns the smallest of two numbers.
+     */
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    /**
+     * @dev Returns the average of two numbers. The result is rounded towards
+     * zero.
+     */
+    function average(uint256 a, uint256 b) internal pure returns (uint256) {
+        // (a + b) / 2 can overflow, so we distribute
+        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
+    }
+}
+
+/**
+ * @dev Contract module that helps prevent reentrant calls to a function.
+ *
+ * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
+ * available, which can be applied to functions to make sure there are no nested
+ * (reentrant) calls to them.
+ *
+ * Note that because there is a single `nonReentrant` guard, functions marked as
+ * `nonReentrant` may not call one another. This can be worked around by making
+ * those functions `private`, and then adding `external` `nonReentrant` entry
+ * points to them.
+ *
+ * TIP: If you would like to learn more about reentrancy and alternative ways
+ * to protect against it, check out our blog post
+ * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
+ */
+abstract contract ReentrancyGuard {
+    // Booleans are more expensive than uint256 or any type that takes up a full
+    // word because each write operation emits an extra SLOAD to first read the
+    // slot's contents, replace the bits taken up by the boolean, and then write
+    // back. This is the compiler's defense against contract upgrades and
+    // pointer aliasing, and it cannot be disabled.
+
+    // The values being non-zero value makes deployment a bit more expensive,
+    // but in exchange the refund on every call to nonReentrant will be lower in
+    // amount. Since refunds are capped to a percentage of the total
+    // transaction's gas, it is best to keep them low in cases like this one, to
+    // increase the likelihood of the full refund coming into effect.
+    uint256 private constant _NOT_ENTERED = 1;
+    uint256 private constant _ENTERED = 2;
+
+    uint256 private _status;
+
+    constructor() {
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and make it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        _status = _ENTERED;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _status = _NOT_ENTERED;
+    }
+}
+
+contract ProtocolGovernance {
+    /// @notice governance address for the governance contract
+    address public governance;
+    address public pendingGovernance;
+
+    /**
+     * @notice Allows governance to change governance (for future upgradability)
+     * @param _governance new governance address to set
+     */
+    function setGovernance(address _governance) external {
+        require(msg.sender == governance, "setGovernance: !gov");
+        pendingGovernance = _governance;
+    }
+
+    /**
+     * @notice Allows pendingGovernance to accept their role as governance (protection pattern)
+     */
+    function acceptGovernance() external {
+        require(
+            msg.sender == pendingGovernance,
+            "acceptGovernance: !pendingGov"
+        );
+        governance = pendingGovernance;
+    }
+}
+
+interface IJar {
+    function balanceOf(address account) external view returns (uint256);
+
+    function totalSupply() external view returns (uint256);
+}
+
+interface iGaugeV2 {
+    function notifyRewardAmount(uint256[] memory rewards) external;
+}
+
+contract VirtualBalanceWrapper {
+    IJar public jar;
+
+    function totalSupply() public view returns (uint256) {
+        return jar.totalSupply();
+    }
+
+    function balanceOf(address account) public view returns (uint256) {
+        return jar.balanceOf(account);
+    }
+}
+
+contract VirtualGaugeV2 is
+    ProtocolGovernance,
+    ReentrancyGuard,
+    VirtualBalanceWrapper
+{
+    using SafeERC20 for IERC20;
+    // Token addresses
+    IERC20 public constant DILL =
+        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
+
+    // Constant for various precisions
+    uint256 private constant _MultiplierPrecision = 1e18;
+
+    address public immutable DISTRIBUTION;
+    uint256 public constant DURATION = 7 days;
+
+    // Lock time and multiplier
+    uint256 public lockMaxMultiplier = uint256(25e17); // E18. 1x = e18
+    uint256 public lockTimeForMaxMultiplier = 365 * 86400; // 1 year
+    uint256 public lockTimeMin = 86400; // 1 day
+
+    //Reward addresses, rates, and symbols
+    address[] public rewardTokens;
+    uint256[] public rewardRates;
+    string[] public rewardSymbols;
+
+    // Time tracking
+    uint256 public periodFinish = 0;
+    uint256 public lastUpdateTime;
+
+    // Rewards tracking
+    mapping(address => mapping(uint256 => uint256))
+        private userRewardPerTokenPaid;
+    mapping(address => mapping(uint256 => uint256)) public _rewards;
+    mapping(address => bool) public authorisedAddress;
+    uint256[] private rewardPerTokenStored;
+    uint256 public multiplierDecayPerSecond = uint256(48e9);
+    mapping(address => mapping(uint256 => uint256)) private _lastUsedMultiplier;
+    mapping(address => uint256) private _lastRewardClaimTime; // staker addr -> timestamp
+
+    // Balance tracking
+    uint256 public derivedSupply;
+    mapping(address => uint256) public derivedBalances;
+    mapping(address => uint256) private _base;
+
+    // Stake tracking
+    mapping(address => LockedStake[]) private _lockedStakes;
+
+    // Administrative booleans
+    bool public stakesUnlocked; // Release locked stakes in case of emergency
+    mapping(address => bool) public stakesUnlockedForAccount; // Release locked stakes of an account in case of emergency
+
+    /* ========== STRUCTS ========== */
+
+    struct LockedStake {
+        uint256 start_timestamp;
+        uint256 liquidity;
+        uint256 ending_timestamp;
+        uint256 lock_multiplier;
+        bool isPermanentlyLocked;
+    }
+
+    /* ========== MODIFIERS ========== */
+
+    modifier onlyDistribution() {
+        require(
+            msg.sender == DISTRIBUTION,
+            "Caller is not RewardsDistribution contract"
+        );
+        _;
+    }
+
+    modifier onlyGov() {
+        require(
+            msg.sender == governance,
+            "Operation allowed by only governance"
+        );
+        _;
+    }
+
+    modifier lockable(uint256 secs) {
+        require(secs >= lockTimeMin, "Minimum stake time not met");
+        require(
+            secs <= lockTimeForMaxMultiplier,
+            "Trying to lock for too long"
+        );
+        _;
+    }
+
+    modifier updateReward(address account, bool isClaimReward) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateTime = lastTimeRewardApplicable();
+
+        if (account != address(0)) {
+            uint256[] memory earnedArr = earned(account);
+            for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
+                _rewards[account][i] = earnedArr[i];
+                userRewardPerTokenPaid[account][i] = rewardPerTokenStored[i];
+            }
+        }
+        _;
+        if (account != address(0)) {
+            kick(account);
+            if (isClaimReward) {
+                _lastRewardClaimTime[account] = block.timestamp;
+            }
+        }
+    }
+
+    modifier onlyJarAndAuthorised() {
+        require(
+            msg.sender == address(jar) || authorisedAddress[msg.sender],
+            "Sender not an authorized jar or address."
+        );
+        _;
+    }
+
+    /* ========== CONSTRUCTOR ========== */
+
+    constructor(
+        address _jar,
+        address _governance,
+        address _distribution,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) {
+        require(_jar != address(0), "cannot set zero address");
+        jar = IJar(_jar);
+        rewardTokens = _rewardTokens;
+        rewardSymbols = _rewardSymbols;
+
+        DISTRIBUTION = _distribution;
+        governance = _governance;
+
+        for (uint256 i = 0; i < _rewardTokens.length; i++) {
+            // Initialize the stored rewards
+            rewardRates.push(0);
+            rewardPerTokenStored.push(0);
+        }
+    }
+
+    /* ========== VIEWS ========== */
+    function lastTimeRewardApplicable() public view returns (uint256) {
+        return Math.min(block.timestamp, periodFinish);
+    }
+
+    function rewardPerToken()
+        public
+        view
+        returns (uint256[] memory newRewardsPerTokenStored)
+    {
+        if (totalSupply() == 0) {
+            return rewardPerTokenStored;
+        } else {
+            newRewardsPerTokenStored = new uint256[](rewardTokens.length);
+            for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
+                newRewardsPerTokenStored[i] =
+                    rewardPerTokenStored[i] +
+                    (((lastTimeRewardApplicable() - lastUpdateTime) *
+                        rewardRates[i] *
+                        1e18) / derivedSupply);
+            }
+            return newRewardsPerTokenStored;
+        }
+    }
+
+    // All the locked stakes for a given account
+    function lockedStakesOf(address account)
+        external
+        view
+        returns (LockedStake[] memory)
+    {
+        return _lockedStakes[account];
+    }
+
+    function earned(address account)
+        public
+        view
+        returns (uint256[] memory newEarned)
+    {
+        uint256[] memory rewardArr = rewardPerToken();
+        newEarned = new uint256[](rewardTokens.length);
+
+        if (derivedBalances[account] == 0) {
+            for (uint256 i = 0; i < rewardTokens.length; i++) {
+                newEarned[i] = 0;
+            }
+        } else {
+            for (uint256 i = 0; i < rewardTokens.length; i++) {
+                newEarned[i] =
+                    ((derivedBalances[account] *
+                        (rewardArr[i] - userRewardPerTokenPaid[account][i])) /
+                        1e18) +
+                    _rewards[account][i];
+            }
+        }
+    }
+
+    function getRewardForDuration()
+        external
+        view
+        returns (uint256[] memory rewardsPerDurationArr)
+    {
+        rewardsPerDurationArr = new uint256[](rewardRates.length);
+
+        for (uint256 i = 0; i < rewardRates.length; i++) {
+            rewardsPerDurationArr[i] = rewardRates[i] * DURATION;
+        }
+    }
+
+    // Multiplier amount, given the length of the lock
+    function lockMultiplier(uint256 secs) public view returns (uint256) {
+        uint256 lock_multiplier = uint256(_MultiplierPrecision) +
+            ((secs * (lockMaxMultiplier - _MultiplierPrecision)) /
+                (lockTimeForMaxMultiplier));
+        if (lock_multiplier > lockMaxMultiplier)
+            lock_multiplier = lockMaxMultiplier;
+        return lock_multiplier;
+    }
+
+    function _averageDecayedLockMultiplier(
+        address account,
+        uint256 index,
+        uint256 elapsedSeconds
+    ) internal view returns (uint256) {
+        return
+            (2 *
+                _lastUsedMultiplier[account][index] -
+                (elapsedSeconds - 1) *
+                multiplierDecayPerSecond) / 2;
+    }
+
+    function setJar(address _jar) external onlyGov {
+        require(_jar != address(0), "cannot set to zero");
+        require(_jar != address(jar), "Jar is already set");
+        jar = IJar(_jar);
+    }
+
+    function setAuthoriseAddress(address _account, bool value)
+        external
+        onlyGov
+    {
+        require(
+            authorisedAddress[_account] != value,
+            "address is already set to given value"
+        );
+        authorisedAddress[_account] = value;
+    }
+
+    function derivedBalance(address account) public returns (uint256) {
+        uint256 _balance = balanceOf(account);
+        uint256 _derived = (_balance * 40) / 100;
+        uint256 _adjusted = (((totalSupply() * DILL.balanceOf(account)) /
+            DILL.totalSupply()) * 60) / 100;
+        uint256 dillBoostedDerivedBal = Math.min(
+            _derived + _adjusted,
+            _balance
+        );
+
+        // Loop through the locked stakes, first by getting the liquidity * lock_multiplier portion
+        uint256 lockBoostedDerivedBal = 0;
+        for (uint256 i = 0; i < _lockedStakes[account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[account][i];
+            uint256 lock_multiplier = thisStake.lock_multiplier;
+            uint256 lastRewardClaimTime = _lastRewardClaimTime[account];
+            // If the lock is expired
+            if (
+                thisStake.ending_timestamp <= block.timestamp &&
+                !thisStake.isPermanentlyLocked
+            ) {
+                // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
+                if (lastRewardClaimTime < thisStake.ending_timestamp) {
+                    uint256 timeBeforeExpiry = thisStake.ending_timestamp -
+                        lastRewardClaimTime;
+                    uint256 timeAfterExpiry = block.timestamp -
+                        thisStake.ending_timestamp;
+
+                    // Get the weighted-average lock_multiplier
+                    uint256 numerator = (lock_multiplier * timeBeforeExpiry) +
+                        (_MultiplierPrecision * timeAfterExpiry);
+                    lock_multiplier =
+                        numerator /
+                        (timeBeforeExpiry + timeAfterExpiry);
+                }
+                // Otherwise, it needs to just be 1x
+                else {
+                    lock_multiplier = _MultiplierPrecision;
+                }
+            } else {
+                uint256 elapsedSeconds = block.timestamp - lastRewardClaimTime;
+                if (elapsedSeconds > 0) {
+                    lock_multiplier = thisStake.isPermanentlyLocked
+                        ? lockMaxMultiplier
+                        : _averageDecayedLockMultiplier(
+                            account,
+                            i,
+                            elapsedSeconds
+                        );
+                    _lastUsedMultiplier[account][i] =
+                        _lastUsedMultiplier[account][i] -
+                        (elapsedSeconds - 1) *
+                        multiplierDecayPerSecond;
+                }
+            }
+            uint256 liquidity = thisStake.liquidity;
+            uint256 combined_boosted_amount = (liquidity * lock_multiplier) /
+                _MultiplierPrecision;
+            lockBoostedDerivedBal =
+                lockBoostedDerivedBal +
+                combined_boosted_amount;
+        }
+
+        return dillBoostedDerivedBal + lockBoostedDerivedBal;
+    }
+
+    /* ========== MUTATIVE FUNCTIONS ========== */
+
+    function kick(address account) public {
+        uint256 _derivedBalance = derivedBalances[account];
+        derivedSupply = derivedSupply - _derivedBalance;
+        _derivedBalance = derivedBalance(account);
+        derivedBalances[account] = _derivedBalance;
+        derivedSupply = derivedSupply + _derivedBalance;
+    }
+
+    function depositFor(uint256 amount, address account)
+        external
+        onlyJarAndAuthorised
+    {
+        _deposit(amount, account, 0, block.timestamp, false);
+    }
+
+    function depositForAndLock(
+        uint256 amount,
+        address account,
+        uint256 secs,
+        bool isPermanentlyLocked
+    ) external lockable(secs) onlyJarAndAuthorised {
+        _deposit(amount, account, secs, block.timestamp, isPermanentlyLocked);
+    }
+
+    function _deposit(
+        uint256 amount,
+        address account,
+        uint256 secs,
+        uint256 start_timestamp,
+        bool isPermanentlyLocked
+    ) internal nonReentrant updateReward(account, false) {
+        require(amount > 0, "Cannot stake 0");
+        uint256 MaxMultiplier = lockMultiplier(secs);
+        _lockedStakes[account].push(
+            LockedStake(
+                start_timestamp,
+                amount,
+                start_timestamp + secs,
+                MaxMultiplier,
+                isPermanentlyLocked
+            )
+        );
+        _lastUsedMultiplier[account][
+            _lockedStakes[account].length - 1
+        ] = MaxMultiplier;
+
+        // Needed for edge case if the staker only claims once, and after the lock expired
+        if (_lastRewardClaimTime[account] == 0)
+            _lastRewardClaimTime[account] = block.timestamp;
+        emit Staked(account, amount, secs, _lockedStakes[account].length - 1);
+    }
+
+    function withdraw(address account, uint256 index)
+        external
+        onlyJarAndAuthorised
+        returns (uint256)
+    {
+        return _withdraw(account, index);
+    }
+
+    function withdrawAll(address account)
+        public
+        onlyJarAndAuthorised
+        returns (uint256 amount)
+    {
+        amount = _partialWithdrawal(account, balanceOf(account));
+        emit WithdrawnAll(account, amount);
+    }
+
+    function partialWithdrawal(address account, uint256 _amount)
+        external
+        onlyJarAndAuthorised
+        returns (uint256 amount)
+    {
+        amount = _partialWithdrawal(account, _amount);
+        emit WithdrawnPartilly(account, amount);
+    }
+
+    function _partialWithdrawal(address _account, uint256 _amount)
+        internal
+        nonReentrant
+        updateReward(_account, false)
+        returns (uint256)
+    {
+        require(
+            _amount <= balanceOf(_account),
+            "Withdraw amount exceeds balance"
+        );
+        uint256 amountToTransfer = 0;
+        for (uint256 i = 0; i < _lockedStakes[_account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[_account][i];
+            // check if stake is not locked
+            uint256 amountRemaining = _amount - amountToTransfer;
+            if (
+                thisStake.liquidity > 0 &&
+                (stakesUnlocked ||
+                    stakesUnlockedForAccount[_account] ||
+                    (!thisStake.isPermanentlyLocked &&
+                        block.timestamp >= thisStake.ending_timestamp))
+            ) {
+                if (thisStake.liquidity < amountRemaining) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                } else if (thisStake.liquidity == amountRemaining) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                    break;
+                } else if (thisStake.liquidity > amountRemaining) {
+                    _lockedStakes[_account][i].liquidity -= amountRemaining;
+                    amountToTransfer = _amount;
+                    break;
+                }
+            }
+        }
+        return amountToTransfer;
+    }
+
+    function _withdraw(address account, uint256 index)
+        internal
+        nonReentrant
+        updateReward(account, false)
+        returns (uint256)
+    {
+        LockedStake memory thisStake;
+        require(index < _lockedStakes[account].length, "Stake not found");
+
+        thisStake = _lockedStakes[account][index];
+
+        require(
+            stakesUnlocked ||
+                stakesUnlockedForAccount[account] ||
+                (
+                    thisStake.isPermanentlyLocked
+                        ? false
+                        : block.timestamp >= thisStake.ending_timestamp
+                ),
+            "Stake is still locked!"
+        );
+
+        if (thisStake.liquidity > 0) {
+            delete _lockedStakes[account][index];
+            emit Withdrawn(account, thisStake.liquidity, index);
+        }
+        return thisStake.liquidity;
+    }
+
+    function getReward(address account)
+        public
+        nonReentrant
+        updateReward(account, true)
+        onlyJarAndAuthorised
+        returns (uint256 _rewardsForJar)
+    {
+        uint256 reward;
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            reward = _rewards[account][i];
+            if (reward > 0) {
+                _rewards[account][i] = 0;
+                _rewardsForJar += reward;
+                IERC20(rewardTokens[i]).safeTransfer(account, reward);
+                emit RewardPaid(account, rewardSymbols[i], reward);
+            }
+        }
+    }
+
+    function exit(address account) external {
+        withdrawAll(account);
+        getReward(account);
+    }
+
+    /* ========== RESTRICTED FUNCTIONS ========== */
+
+    function notifyRewardAmount(uint256[] memory rewards)
+        external
+        onlyDistribution
+        updateReward(address(0), false)
+    {
+        require(
+            rewards.length == rewardTokens.length,
+            "Rewards count do not match reward token count"
+        );
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            IERC20(rewardTokens[i]).safeTransferFrom(
+                DISTRIBUTION,
+                address(this),
+                rewards[i]
+            );
+
+            if (block.timestamp >= periodFinish) {
+                rewardRates[i] = rewards[i] / DURATION;
+            } else {
+                uint256 remaining = periodFinish - block.timestamp;
+                uint256 leftover = remaining * rewardRates[i];
+                rewardRates[i] = (rewards[i] + leftover) / DURATION;
+            }
+
+            // Ensure the provided reward amount is not more than the balance in the contract.
+            // This keeps the reward rate in the right range, preventing overflows due to
+            // very high values of rewardRate in the earned and rewardsPerToken functions;
+            // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
+            uint256 balance = IERC20(rewardTokens[i]).balanceOf(address(this));
+            require(
+                rewardRates[i] <= balance / DURATION,
+                "Provided reward too high"
+            );
+
+            emit RewardAdded(rewardSymbols[i], rewards[i]);
+        }
+
+        lastUpdateTime = block.timestamp;
+        periodFinish = block.timestamp + DURATION;
+    }
+
+    function setMultipliers(uint256 _lock_max_multiplier) external onlyGov {
+        require(
+            _lock_max_multiplier >= uint256(1e18),
+            "Multiplier must be greater than or equal to 1e18"
+        );
+        lockMaxMultiplier = _lock_max_multiplier;
+        emit LockedStakeMaxMultiplierUpdated(lockMaxMultiplier);
+    }
+
+    function setMaxRewardsDuration(uint256 _lockTimeForMaxMultiplier)
+        external
+        onlyGov
+    {
+        require(
+            _lockTimeForMaxMultiplier >= 86400,
+            "Rewards duration too short"
+        );
+        require(
+            periodFinish == 0 || block.timestamp > periodFinish,
+            "Reward period incomplete"
+        );
+        lockTimeForMaxMultiplier = _lockTimeForMaxMultiplier;
+        emit MaxRewardsDurationUpdated(lockTimeForMaxMultiplier);
+    }
+
+    function unlockStakes() external onlyGov {
+        stakesUnlocked = !stakesUnlocked;
+    }
+
+    function unlockStakeForAccount(address account) external onlyGov {
+        stakesUnlockedForAccount[account] = !stakesUnlockedForAccount[account];
+    }
+
+    /* ========== EVENTS ========== */
+    event approvedTokenReceipt(address _spender, uint256 _amount);
+    event stakeTransferd(address _to, uint256 _index);
+    event allStakesTransferd(address _to);
+    event RewardAdded(string rewardSymbol, uint256 reward);
+    event Staked(
+        address indexed user,
+        uint256 amount,
+        uint256 secs,
+        uint256 index
+    );
+    event Withdrawn(address indexed user, uint256 amount, uint256 index);
+    event WithdrawnAll(address indexed user, uint256 amount);
+    event WithdrawnPartilly(address indexed user, uint256 amount);
+    event RewardPaid(address indexed user, string rewardSymbol, uint256 reward);
+    event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
+    event MaxRewardsDurationUpdated(uint256 newDuration);
+}
+
+contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
+    using SafeERC20 for IERC20;
+
+    // Token addresses
+    IERC20 public constant PICKLE =
+        IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
+    IERC20 public constant DILL =
+        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
+    address public constant TREASURY =
+        address(0x066419EaEf5DE53cc5da0d8702b990c5bc7D1AB3);
+
+    // Constant for various precisions
+    uint256 private constant _MultiplierPrecision = 1e18;
+
+    IERC20 public immutable TOKEN;
+    address public immutable DISTRIBUTION;
+    uint256 public constant DURATION = 7 days;
+
+    // Lock time and multiplier
+    uint256 public lockMaxMultiplier = uint256(25e17); // E18. 1x = e18
+    uint256 public lockTimeForMaxMultiplier = 365 * 86400; // 1 year
+    uint256 public lockTimeMin = 86400; // 1 day
+
+    //Reward addresses, rates, and symbols
+    address[] public rewardTokens;
+    uint256[] public rewardRates;
+    string[] public rewardSymbols;
+
+    // Time tracking
+    uint256 public periodFinish = 0;
+    uint256 public lastUpdateTime;
+
+    // Rewards tracking
+    mapping(address => mapping(uint256 => uint256))
+        private userRewardPerTokenPaid;
+    mapping(address => mapping(uint256 => uint256)) public _rewards;
+    uint256[] private rewardPerTokenStored;
+    uint256 public multiplierDecayPerSecond = uint256(48e9);
+    mapping(address => mapping(uint256 => uint256)) private _lastUsedMultiplier;
+    mapping(address => uint256) private _lastRewardClaimTime; // staker addr -> timestamp
+
+    // Balance tracking
+    uint256 private _totalSupply;
+    uint256 public derivedSupply;
+    mapping(address => uint256) private _balances;
+    mapping(address => uint256) public derivedBalances;
+    mapping(address => uint256) private _base;
+
+    // Delegate tracking
+    mapping(address => mapping(address => bool)) public stakingDelegates;
+
+    // Stake tracking
+    mapping(address => LockedStake[]) private _lockedStakes;
+
+    // Administrative booleans
+    bool public stakesUnlocked; // Release locked stakes in case of emergency
+    mapping(address => bool) public stakesUnlockedForAccount; // Release locked stakes of an account in case of emergency
+
+    /* ========== STRUCTS ========== */
+
+    struct LockedStake {
+        uint256 start_timestamp;
+        uint256 liquidity;
+        uint256 ending_timestamp;
+        uint256 lock_multiplier;
+        bool isPermanentlyLocked;
+    }
+
+    /* ========== MODIFIERS ========== */
+
+    modifier onlyDistribution() {
+        require(
+            msg.sender == DISTRIBUTION,
+            "Caller is not RewardsDistribution contract"
+        );
+        _;
+    }
+
+    modifier onlyGov() {
+        require(
+            msg.sender == governance,
+            "Operation allowed by only governance"
+        );
+        _;
+    }
+
+    modifier lockable(uint256 secs) {
+        require(secs >= lockTimeMin, "Minimum stake time not met");
+        require(
+            secs <= lockTimeForMaxMultiplier,
+            "Trying to lock for too long"
+        );
+        _;
+    }
+
+    modifier updateReward(address account, bool isClaimReward) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateTime = lastTimeRewardApplicable();
+
+        if (account != address(0)) {
+            uint256[] memory earnedArr = earned(account);
+            for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
+                _rewards[account][i] = earnedArr[i];
+                userRewardPerTokenPaid[account][i] = rewardPerTokenStored[i];
+            }
+        }
+        _;
+        if (account != address(0)) {
+            kick(account);
+            if (isClaimReward) {
+                _lastRewardClaimTime[account] = block.timestamp;
+            }
+        }
+    }
+
+    /* ========== CONSTRUCTOR ========== */
+
+    constructor(
+        address _token,
+        address _governance,
+        address _distribution,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) {
+        TOKEN = IERC20(_token);
+
+        rewardTokens = _rewardTokens;
+        rewardSymbols = _rewardSymbols;
+
+        DISTRIBUTION = _distribution;
+        governance = _governance;
+
+        for (uint256 i = 0; i < _rewardTokens.length; i++) {
+            // Initialize the stored rewards
+            rewardRates.push(0);
+            rewardPerTokenStored.push(0);
+        }
+    }
+
+    /* ========== VIEWS ========== */
+
+    function totalSupply() external view returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return _balances[account];
+    }
+
+    function lastTimeRewardApplicable() public view returns (uint256) {
+        return Math.min(block.timestamp, periodFinish);
+    }
+
+    function rewardPerToken()
+        public
+        view
+        returns (uint256[] memory newRewardsPerTokenStored)
+    {
+        if (_totalSupply == 0) {
+            return rewardPerTokenStored;
+        } else {
+            newRewardsPerTokenStored = new uint256[](rewardTokens.length);
+            for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
+                newRewardsPerTokenStored[i] =
+                    rewardPerTokenStored[i] +
+                    (((lastTimeRewardApplicable() - lastUpdateTime) *
+                        rewardRates[i] *
+                        1e18) / derivedSupply);
+            }
+            return newRewardsPerTokenStored;
+        }
+    }
+
+    // All the locked stakes for a given account
+    function lockedStakesOf(address account)
+        external
+        view
+        returns (LockedStake[] memory)
+    {
+        return _lockedStakes[account];
+    }
+
+    function earned(address account)
+        public
+        view
+        returns (uint256[] memory newEarned)
+    {
+        uint256[] memory rewardArr = rewardPerToken();
+        newEarned = new uint256[](rewardTokens.length);
+
+        if (derivedBalances[account] == 0) {
+            for (uint256 i = 0; i < rewardTokens.length; i++) {
+                newEarned[i] = 0;
+            }
+        } else {
+            for (uint256 i = 0; i < rewardTokens.length; i++) {
+                newEarned[i] =
+                    ((derivedBalances[account] *
+                        (rewardArr[i] - userRewardPerTokenPaid[account][i])) /
+                        1e18) +
+                    _rewards[account][i];
+            }
+        }
+    }
+
+    function getRewardForDuration()
+        external
+        view
+        returns (uint256[] memory rewardsPerDurationArr)
+    {
+        rewardsPerDurationArr = new uint256[](rewardRates.length);
+
+        for (uint256 i = 0; i < rewardRates.length; i++) {
+            rewardsPerDurationArr[i] = rewardRates[i] * DURATION;
+        }
+    }
+
+    // Multiplier amount, given the length of the lock
+    function lockMultiplier(uint256 secs) public view returns (uint256) {
+        uint256 lock_multiplier = uint256(_MultiplierPrecision) +
+            ((secs * (lockMaxMultiplier - _MultiplierPrecision)) /
+                (lockTimeForMaxMultiplier));
+        if (lock_multiplier > lockMaxMultiplier)
+            lock_multiplier = lockMaxMultiplier;
+        return lock_multiplier;
+    }
+
+    function _averageDecayedLockMultiplier(
+        address account,
+        uint256 index,
+        uint256 elapsedSeconds
+    ) internal view returns (uint256) {
+        return
+            (2 *
+                _lastUsedMultiplier[account][index] -
+                (elapsedSeconds - 1) *
+                multiplierDecayPerSecond) / 2;
+    }
+
+    function setStakingDelegate(address _delegate) public {
+        require(
+            !stakingDelegates[msg.sender][_delegate],
+            "Already a staking delegate for user!"
+        );
+        require(_delegate != msg.sender, "Cannot delegate to self");
+        stakingDelegates[msg.sender][_delegate] = true;
+    }
+
+    function derivedBalance(address account) public returns (uint256) {
+        uint256 _balance = _balances[account];
+        uint256 _derived = (_balance * 40) / 100;
+        uint256 _adjusted = (((_totalSupply * DILL.balanceOf(account)) /
+            DILL.totalSupply()) * 60) / 100;
+        uint256 dillBoostedDerivedBal = Math.min(
+            _derived + _adjusted,
+            _balance
+        );
+
+        // Loop through the locked stakes, first by getting the liquidity * lock_multiplier portion
+        uint256 lockBoostedDerivedBal = 0;
+        for (uint256 i = 0; i < _lockedStakes[account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[account][i];
+            uint256 lock_multiplier = thisStake.lock_multiplier;
+            uint256 lastRewardClaimTime = _lastRewardClaimTime[account];
+            // If the lock is expired
+            if (
+                thisStake.ending_timestamp <= block.timestamp &&
+                !thisStake.isPermanentlyLocked
+            ) {
+                // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
+                if (lastRewardClaimTime < thisStake.ending_timestamp) {
+                    uint256 timeBeforeExpiry = thisStake.ending_timestamp -
+                        lastRewardClaimTime;
+                    uint256 timeAfterExpiry = block.timestamp -
+                        thisStake.ending_timestamp;
+
+                    // Get the weighted-average lock_multiplier
+                    uint256 numerator = (lock_multiplier * timeBeforeExpiry) +
+                        (_MultiplierPrecision * timeAfterExpiry);
+                    lock_multiplier =
+                        numerator /
+                        (timeBeforeExpiry + timeAfterExpiry);
+                }
+                // Otherwise, it needs to just be 1x
+                else {
+                    lock_multiplier = _MultiplierPrecision;
+                }
+            } else {
+                uint256 elapsedSeconds = block.timestamp - lastRewardClaimTime;
+                if (elapsedSeconds > 0) {
+                    lock_multiplier = thisStake.isPermanentlyLocked
+                        ? lockMaxMultiplier
+                        : _averageDecayedLockMultiplier(
+                            account,
+                            i,
+                            elapsedSeconds
+                        );
+                    _lastUsedMultiplier[account][i] =
+                        _lastUsedMultiplier[account][i] -
+                        (elapsedSeconds - 1) *
+                        multiplierDecayPerSecond;
+                }
+            }
+            uint256 liquidity = thisStake.liquidity;
+            uint256 combined_boosted_amount = (liquidity * lock_multiplier) /
+                _MultiplierPrecision;
+            lockBoostedDerivedBal =
+                lockBoostedDerivedBal +
+                combined_boosted_amount;
+        }
+
+        return dillBoostedDerivedBal + lockBoostedDerivedBal;
+    }
+
+    /* ========== MUTATIVE FUNCTIONS ========== */
+
+    function kick(address account) public {
+        uint256 _derivedBalance = derivedBalances[account];
+        derivedSupply = derivedSupply - _derivedBalance;
+        _derivedBalance = derivedBalance(account);
+        derivedBalances[account] = _derivedBalance;
+        derivedSupply = derivedSupply + _derivedBalance;
+    }
+
+    function depositAllAndLock(uint256 secs, bool isPermanentlyLocked)
+        external
+        lockable(secs)
+    {
+        _deposit(
+            TOKEN.balanceOf(msg.sender),
+            msg.sender,
+            secs,
+            block.timestamp,
+            isPermanentlyLocked
+        );
+    }
+
+    function depositAll() external {
+        _deposit(
+            TOKEN.balanceOf(msg.sender),
+            msg.sender,
+            0,
+            block.timestamp,
+            false
+        );
+    }
+
+    function depositFor(uint256 amount, address account) external {
+        require(
+            stakingDelegates[account][msg.sender],
+            "Only registered delegates can deposit for their delegator"
+        );
+        _deposit(amount, account, 0, block.timestamp, false);
+    }
+
+    function depositForAndLock(
+        uint256 amount,
+        address account,
+        uint256 secs,
+        bool isPermanentlyLocked
+    ) external lockable(secs) {
+        require(
+            stakingDelegates[account][msg.sender],
+            "Only registered delegates can stake for their delegator"
+        );
+        _deposit(amount, account, secs, block.timestamp, isPermanentlyLocked);
+    }
+
+    function deposit(uint256 amount) external {
+        _deposit(amount, msg.sender, 0, block.timestamp, false);
+    }
+
+    function depositAndLock(
+        uint256 amount,
+        uint256 secs,
+        bool isPermanentlyLocked
+    ) external lockable(secs) {
+        _deposit(
+            amount,
+            msg.sender,
+            secs,
+            block.timestamp,
+            isPermanentlyLocked
+        );
+    }
+
+    function _deposit(
+        uint256 amount,
+        address account,
+        uint256 secs,
+        uint256 start_timestamp,
+        bool isPermanentlyLocked
+    ) internal nonReentrant updateReward(account, false) {
+        require(amount > 0, "Cannot stake 0");
+        uint256 MaxMultiplier = lockMultiplier(secs);
+        _lockedStakes[account].push(
+            LockedStake(
+                start_timestamp,
+                amount,
+                start_timestamp + secs,
+                MaxMultiplier,
+                isPermanentlyLocked
+            )
+        );
+        _lastUsedMultiplier[account][
+            _lockedStakes[account].length - 1
+        ] = MaxMultiplier;
+
+        _totalSupply = _totalSupply + amount;
+        _balances[account] = _balances[account] + amount;
+
+        // Needed for edge case if the staker only claims once, and after the lock expired
+        if (_lastRewardClaimTime[account] == 0)
+            _lastRewardClaimTime[account] = block.timestamp;
+
+        TOKEN.safeTransferFrom(account, address(this), amount);
+        emit Staked(account, amount, secs, _lockedStakes[account].length - 1);
+    }
+
+    function withdraw(uint256 index) external {
+        _withdraw(index);
+    }
+
+    function withdrawAll() public {
+        uint256 amount = _partialWithdrawal(msg.sender, _balances[msg.sender]);
+        emit WithdrawnAll(msg.sender, amount);
+    }
+
+    function partialWithdrawal(uint256 _amount) external {
+        uint256 amount = _partialWithdrawal(msg.sender, _amount);
+        emit WithdrawnPartilly(msg.sender, amount);
+    }
+
+    function _partialWithdrawal(address _account, uint256 _amount)
+        internal
+        nonReentrant
+        updateReward(_account, false)
+        returns (uint256)
+    {
+        require(
+            _amount <= _balances[_account],
+            "Withdraw amount exceeds balance"
+        );
+        uint256 amountToTransfer = 0;
+        for (uint256 i = 0; i < _lockedStakes[_account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[_account][i];
+            // check if stake is not locked
+            uint256 amountRemaining = _amount - amountToTransfer;
+            if (
+                thisStake.liquidity > 0 &&
+                (stakesUnlocked ||
+                    stakesUnlockedForAccount[_account] ||
+                    (!thisStake.isPermanentlyLocked &&
+                        block.timestamp >= thisStake.ending_timestamp))
+            ) {
+                if (thisStake.liquidity < amountRemaining) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                } else if (thisStake.liquidity == amountRemaining) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                    break;
+                } else if (thisStake.liquidity > amountRemaining) {
+                    _lockedStakes[_account][i].liquidity -= amountRemaining;
+                    amountToTransfer = _amount;
+                    break;
+                }
+            }
+        }
+        if (amountToTransfer > 0) {
+            _totalSupply = _totalSupply - amountToTransfer;
+            _balances[_account] = _balances[_account] - amountToTransfer;
+            TOKEN.safeTransfer(msg.sender, amountToTransfer);
+        }
+        return amountToTransfer;
+    }
+
+    function _withdraw(uint256 index)
+        internal
+        nonReentrant
+        updateReward(msg.sender, false)
+    {
+        LockedStake memory thisStake;
+        thisStake.liquidity = 0;
+        require(index < _lockedStakes[msg.sender].length, "Stake not found");
+
+        thisStake = _lockedStakes[msg.sender][index];
+
+        require(
+            stakesUnlocked ||
+                stakesUnlockedForAccount[msg.sender] ||
+                (
+                    thisStake.isPermanentlyLocked
+                        ? false
+                        : block.timestamp >= thisStake.ending_timestamp
+                ),
+            "Stake is still locked!"
+        );
+
+        uint256 liquidity = thisStake.liquidity;
+
+        if (liquidity > 0) {
+            _totalSupply = _totalSupply - liquidity;
+            _balances[msg.sender] = _balances[msg.sender] - liquidity;
+            delete _lockedStakes[msg.sender][index];
+            TOKEN.safeTransfer(msg.sender, liquidity);
+            emit Withdrawn(msg.sender, liquidity, index);
+        }
+    }
+
+    function getReward() public nonReentrant updateReward(msg.sender, true) {
+        uint256 reward;
+        // _lastRewardClaimTime[msg.sender] = block.timestamp;
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            reward = _rewards[msg.sender][i];
+            if (reward > 0) {
+                _rewards[msg.sender][i] = 0;
+                IERC20(rewardTokens[i]).safeTransfer(msg.sender, reward);
+                emit RewardPaid(msg.sender, rewardSymbols[i], reward);
+            }
+        }
+    }
+
+    function exit() external {
+        withdrawAll();
+        getReward();
+    }
+
+    /* ========== RESTRICTED FUNCTIONS ========== */
+
+    function notifyRewardAmount(uint256[] memory rewards)
+        external
+        onlyDistribution
+        updateReward(address(0), false)
+    {
+        require(
+            rewards.length == rewardTokens.length,
+            "Rewards count do not match reward token count"
+        );
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            IERC20(rewardTokens[i]).safeTransferFrom(
+                DISTRIBUTION,
+                address(this),
+                rewards[i]
+            );
+
+            if (block.timestamp >= periodFinish) {
+                rewardRates[i] = rewards[i] / DURATION;
+            } else {
+                uint256 remaining = periodFinish - block.timestamp;
+                uint256 leftover = remaining * rewardRates[i];
+                rewardRates[i] = (rewards[i] + leftover) / DURATION;
+            }
+
+            // Ensure the provided reward amount is not more than the balance in the contract.
+            // This keeps the reward rate in the right range, preventing overflows due to
+            // very high values of rewardRate in the earned and rewardsPerToken functions;
+            // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
+            uint256 balance = IERC20(rewardTokens[i]).balanceOf(address(this));
+            require(
+                rewardRates[i] <= balance / DURATION,
+                "Provided reward too high"
+            );
+
+            emit RewardAdded(rewardSymbols[i], rewards[i]);
+        }
+
+        lastUpdateTime = block.timestamp;
+        periodFinish = block.timestamp + DURATION;
+    }
+
+    function setMultipliers(uint256 _lock_max_multiplier) external onlyGov {
+        require(
+            _lock_max_multiplier >= uint256(1e18),
+            "Multiplier must be greater than or equal to 1e18"
+        );
+        lockMaxMultiplier = _lock_max_multiplier;
+        emit LockedStakeMaxMultiplierUpdated(lockMaxMultiplier);
+    }
+
+    function setMaxRewardsDuration(uint256 _lockTimeForMaxMultiplier)
+        external
+        onlyGov
+    {
+        require(
+            _lockTimeForMaxMultiplier >= 86400,
+            "Rewards duration too short"
+        );
+        require(
+            periodFinish == 0 || block.timestamp > periodFinish,
+            "Reward period incomplete"
+        );
+        lockTimeForMaxMultiplier = _lockTimeForMaxMultiplier;
+        emit MaxRewardsDurationUpdated(lockTimeForMaxMultiplier);
+    }
+
+    function unlockStakes() external onlyGov {
+        stakesUnlocked = !stakesUnlocked;
+    }
+
+    function unlockStakeForAccount(address account) external onlyGov {
+        stakesUnlockedForAccount[account] = !stakesUnlockedForAccount[account];
+    }
+
+    /* ========== EVENTS ========== */
+    event approvedTokenReceipt(address _spender, uint256 _amount);
+    event stakeTransferd(address _to, uint256 _index);
+    event allStakesTransferd(address _to);
+    event RewardAdded(string rewardSymbol, uint256 reward);
+    event Staked(
+        address indexed user,
+        uint256 amount,
+        uint256 secs,
+        uint256 index
+    );
+    event Withdrawn(address indexed user, uint256 amount, uint256 index);
+    event WithdrawnAll(address indexed user, uint256 amount);
+    event WithdrawnPartilly(address indexed user, uint256 amount);
+    event RewardPaid(address indexed user, string rewardSymbol, uint256 reward);
+    event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
+    event MaxRewardsDurationUpdated(uint256 newDuration);
+}
+
+interface MasterChef {
+    function deposit(uint256, uint256) external;
+
+    function withdraw(uint256, uint256) external;
+
+    function userInfo(uint256, address)
+        external
+        view
+        returns (uint256, uint256);
+}
+
+contract MasterDill {
+    /// @notice EIP-20 token name for this token
+    string public constant name = "Master DILL";
+
+    /// @notice EIP-20 token symbol for this token
+    string public constant symbol = "mDILL";
+
+    /// @notice EIP-20 token decimals for this token
+    uint8 public constant decimals = 18;
+
+    /// @notice Total number of tokens in circulation
+    uint256 public totalSupply = 1e18;
+
+    mapping(address => mapping(address => uint256)) internal allowances;
+    mapping(address => uint256) internal balances;
+
+    /// @notice The standard EIP-20 transfer event
+    event Transfer(address indexed from, address indexed to, uint256 amount);
+
+    /// @notice The standard EIP-20 approval event
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 amount
+    );
+
+    constructor() {
+        balances[msg.sender] = 1e18;
+        emit Transfer(address(0x0), msg.sender, 1e18);
+    }
+
+    /**
+     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
+     * @param account The address of the account holding the funds
+     * @param spender The address of the account spending the funds
+     * @return The number of tokens approved
+     */
+    function allowance(address account, address spender)
+        external
+        view
+        returns (uint256)
+    {
+        return allowances[account][spender];
+    }
+
+    /**
+     * @notice Approve `spender` to transfer up to `amount` from `src`
+     * @dev This will overwrite the approval amount for `spender`
+     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
+     * @param spender The address of the account which may transfer tokens
+     * @param amount The number of tokens that are approved (2^256-1 means infinite)
+     * @return Whether or not the approval succeeded
+     */
+    function approve(address spender, uint256 amount) external returns (bool) {
+        allowances[msg.sender][spender] = amount;
+
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+
+    /**
+     * @notice Get the number of tokens held by the `account`
+     * @param account The address of the account to get the balance of
+     * @return The number of tokens held
+     */
+    function balanceOf(address account) external view returns (uint256) {
+        return balances[account];
+    }
+
+    /**
+     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
+     * @param dst The address of the destination account
+     * @param amount The number of tokens to transfer
+     * @return Whether or not the transfer succeeded
+     */
+    function transfer(address dst, uint256 amount) external returns (bool) {
+        _transferTokens(msg.sender, dst, amount);
+        return true;
+    }
+
+    /**
+     * @notice Transfer `amount` tokens from `src` to `dst`
+     * @param src The address of the source account
+     * @param dst The address of the destination account
+     * @param amount The number of tokens to transfer
+     * @return Whether or not the transfer succeeded
+     */
+    function transferFrom(
+        address src,
+        address dst,
+        uint256 amount
+    ) external returns (bool) {
+        address spender = msg.sender;
+        uint256 spenderAllowance = allowances[src][spender];
+        require(
+            amount <= spenderAllowance,
+            "transferFrom: exceeds spender allowance"
+        );
+
+        if (spender != src && spenderAllowance != type(uint256).max) {
+            uint256 newAllowance = spenderAllowance - amount;
+            allowances[src][spender] = newAllowance;
+
+            emit Approval(src, spender, newAllowance);
+        }
+
+        _transferTokens(src, dst, amount);
+        return true;
+    }
+
+    function _transferTokens(
+        address src,
+        address dst,
+        uint256 amount
+    ) internal {
+        require(src != address(0), "_transferTokens: zero address");
+        require(dst != address(0), "_transferTokens: zero address");
+        require(amount <= balances[src], "_transferTokens: exceeds balance");
+
+        balances[src] -= amount;
+        balances[dst] += amount;
+        emit Transfer(src, dst, amount);
+    }
+}
+
+/**
+ * @title Initializable
+ *
+ * @dev Helper contract to support initializer functions. To use it, replace
+ * the constructor with a function that has the `initializer` modifier.
+ * WARNING: Unlike constructors, initializer functions must be manually
+ * invoked. This applies both to deploying an Initializable contract, as well
+ * as extending an Initializable contract via inheritance.
+ * WARNING: When used with inheritance, manual care must be taken to not invoke
+ * a parent initializer twice, or ensure that all initializers are idempotent,
+ * because this is not dealt with automatically as with constructors.
+ */
+contract Initializable {
+    /**
+     * @dev Indicates that the contract has been initialized.
+     */
+    bool private initialized;
+
+    /**
+     * @dev Indicates that the contract is in the process of being initialized.
+     */
+    bool private initializing;
+
+    /**
+     * @dev Modifier to use in the initializer function of a contract.
+     */
+    modifier initializer() {
+        require(
+            initializing || isConstructor() || !initialized,
+            "Contract instance has already been initialized"
+        );
+
+        bool isTopLevelCall = !initializing;
+        if (isTopLevelCall) {
+            initializing = true;
+            initialized = true;
+        }
+
+        _;
+
+        if (isTopLevelCall) {
+            initializing = false;
+        }
+    }
+
+    /// @dev Returns true if and only if the function is running in the constructor
+    function isConstructor() private view returns (bool) {
+        // extcodesize checks the size of the code stored in an address, and
+        // address returns the current address. Since the code is still not
+        // deployed when running a constructor, any checks on its code size will
+        // yield zero, making it an effective way to detect if a contract is
+        // under construction or not.
+        address self = address(this);
+        uint256 cs;
+        assembly {
+            cs := extcodesize(self)
+        }
+        return cs == 0;
+    }
+
+    // Reserved storage space to allow for layout changes in the future.
+    uint256[50] private ______gap;
+}
+
+contract GaugeProxyV2 is ProtocolGovernance, Initializable {
+    using SafeERC20 for IERC20;
+
+    MasterChef public constant MASTER =
+        MasterChef(0xbD17B1ce622d73bD438b9E658acA5996dc394b0d);
+    IERC20 public constant DILL =
+        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
+    IERC20 public constant PICKLE =
+        IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
+
+    IERC20 public TOKEN;
+
+    uint256 public pid;
+
+    address[] internal _tokens;
+
+    // token => gauge
+    mapping(address => address) public gauges;
+    mapping(address => uint256) public gaugeWithNegativeWeight;
+    mapping(address => bool) public isVirtualGauge;
+
+    uint256 public constant WEEK_SECONDS = 604800;
+    // epoch time stamp
+    uint256 public firstDistribution;
+    uint256 public distributionId;
+    uint256 public lastVotedPeriodId;
+
+    mapping(address => uint256) public tokenLastVotedPeriodId; // token => last voted period id
+    mapping(address => int256) public usedWeights; // msg.sender => total voting weight of user
+    mapping(address => address[]) public tokenVote; // msg.sender => token
+    mapping(address => mapping(address => int256)) public votes; // msg.sender => votes
+    mapping(uint256 => mapping(address => int256)) public weights; // period id => token => weight
+    mapping(uint256 => int256) public totalWeight; // period id => TotalWeight
+    mapping(uint256 => mapping(uint256 => bool)) public distributed;
+    mapping(uint256 => uint256) public periodForDistribute; // dist id => which period id votes to use
+    IGaugeMiddleware public gaugeMiddleware;
+    IVirtualGaugeMiddleware public virtualGaugeMiddleware;
+
+    struct delegateData {
+        // delegated address
+        address delegate;
+        // previous delegated address if updated, else zero address
+        address prevDelegate;
+        // period id when delegate address was updated
+        uint256 updatePeriodId;
+        // endPeriod if defined. Else 0.
+        uint256 endPeriod;
+        // If no endPeriod
+        bool indefinite;
+        // Period => Boolean (if delegate address can vote in that period)
+        mapping(uint256 => bool) blockDelegate;
+    }
+
+    mapping(address => delegateData) public delegations;
+
+    function getCurrentPeriodId() public view returns (uint256) {
+        return
+            block.timestamp > firstDistribution
+                ? ((block.timestamp - firstDistribution) / WEEK_SECONDS) + 1
+                : 0;
+    }
+
+    function tokens() external view returns (address[] memory) {
+        return _tokens;
+    }
+
+    function getGauge(address _token) external view returns (address) {
+        return gauges[_token];
+    }
+
+    function initialize(uint256 _firstDistribution) public initializer {
+        TOKEN = IERC20(address(new MasterDill()));
+        governance = msg.sender;
+        firstDistribution = _firstDistribution;
+        distributionId = 1;
+        lastVotedPeriodId = 1;
+        periodForDistribute[1] = 1;
+    }
+
+    function addGaugeMiddleware(address _gaugeMiddleware) external {
+        require(
+            _gaugeMiddleware != address(0),
+            "gaugeMiddleware cannot set to zero"
+        );
+        require(
+            _gaugeMiddleware != address(gaugeMiddleware),
+            "current and new gaugeMiddleware are same"
+        );
+        gaugeMiddleware = IGaugeMiddleware(_gaugeMiddleware);
+    }
+
+    function addVirtualGaugeMiddleware(address _virtualGaugeMiddleware)
+        external
+    {
+        require(
+            _virtualGaugeMiddleware != address(0),
+            "virtualGaugeMiddleware cannot set to zero"
+        );
+        require(
+            _virtualGaugeMiddleware != address(gaugeMiddleware),
+            "current and new virtualGaugeMiddleware are same"
+        );
+        virtualGaugeMiddleware = IVirtualGaugeMiddleware(
+            _virtualGaugeMiddleware
+        );
+    }
+
+    // Reset votes to 0
+    function reset() external {
+        uint256 currentId = getCurrentPeriodId();
+        // require(currentId > 0, "Voting not started yet");
+        _reset(msg.sender, currentId);
+    }
+
+    // Reset votes to 0
+    function _reset(address _owner, uint256 _currentId) internal {
+        address[] storage _tokenVote = tokenVote[_owner];
+        uint256 _tokenVoteCnt = _tokenVote.length;
+        require(_currentId > 0, "Voting not started");
+
+        if (_currentId > lastVotedPeriodId) {
+            totalWeight[_currentId] = totalWeight[lastVotedPeriodId];
+            lastVotedPeriodId = _currentId;
+        }
+
+        for (uint256 i = 0; i < _tokenVoteCnt; i++) {
+            address _token = _tokenVote[i];
+            int256 _votes = votes[_owner][_token];
+
+            if (_votes != 0) {
+                totalWeight[_currentId] -= (_votes > 0 ? _votes : -_votes);
+
+                if (_currentId > tokenLastVotedPeriodId[_token]) {
+                    weights[_currentId][_token] = weights[
+                        tokenLastVotedPeriodId[_token]
+                    ][_token];
+
+                    tokenLastVotedPeriodId[_token] = _currentId;
+                }
+
+                weights[_currentId][_token] -= _votes;
+                votes[_owner][_token] = 0;
+            }
+        }
+
+        delete tokenVote[_owner];
+        // Ensure distribute _rewards are for current period
+        periodForDistribute[_currentId] = _currentId;
+    }
+
+    // Adjusts _owner's votes according to latest _owner's DILL balance
+    function poke(address _owner) public {
+        address[] memory _tokenVote = tokenVote[_owner];
+        uint256 _tokenCnt = _tokenVote.length;
+        int256[] memory _weights = new int256[](_tokenCnt);
+        uint256 currentId = getCurrentPeriodId();
+
+        int256 _prevUsedWeight = usedWeights[_owner];
+        int256 _weight = int256(DILL.balanceOf(_owner));
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            int256 _prevWeight = votes[_owner][_tokenVote[i]];
+            _weights[i] = (_prevWeight * (_weight)) / (_prevUsedWeight);
+        }
+        _vote(_owner, _tokenVote, _weights, currentId);
+    }
+
+    function _vote(
+        address _owner,
+        address[] memory _tokenVote,
+        int256[] memory _weights,
+        uint256 _currentId
+    ) internal {
+        _reset(_owner, _currentId);
+        uint256 _tokenCnt = _tokenVote.length;
+        int256 _weight = int256(DILL.balanceOf(_owner));
+        int256 _totalVoteWeight = 0;
+        int256 _usedWeight = 0;
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            _totalVoteWeight += (_weights[i] > 0 ? _weights[i] : -_weights[i]);
+        }
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            address _token = _tokenVote[i];
+            address _gauge = gauges[_token];
+            int256 _tokenWeight = (_weights[i] * _weight) / _totalVoteWeight;
+            if (_gauge != address(0x0)) {
+                if (_currentId > tokenLastVotedPeriodId[_token]) {
+                    weights[_currentId][_token] = weights[
+                        tokenLastVotedPeriodId[_token]
+                    ][_token];
+
+                    tokenLastVotedPeriodId[_token] = _currentId;
+                }
+
+                weights[_currentId][_token] += _tokenWeight;
+                votes[_owner][_token] = _tokenWeight;
+                tokenVote[_owner].push(_token);
+
+                if (_tokenWeight < 0) _tokenWeight = -_tokenWeight;
+
+                _usedWeight += _tokenWeight;
+                totalWeight[_currentId] += _tokenWeight;
+            }
+        }
+        usedWeights[_owner] = _usedWeight;
+    }
+
+    // Vote with DILL on a gauge
+    function vote(address[] calldata _tokenVote, int256[] calldata _weights)
+        external
+    {
+        require(
+            _tokenVote.length == _weights.length,
+            "GaugeProxy: token votes count does not match weights count"
+        );
+        uint256 currentId = getCurrentPeriodId();
+        require(currentId > 0, "Voting not started yet");
+        _vote(msg.sender, _tokenVote, _weights, currentId);
+        delegations[msg.sender].blockDelegate[currentId] = true;
+    }
+
+    function setVotingDelegate(
+        address _delegateAddress,
+        uint256 _periodsCount,
+        bool _indefinite
+    ) external {
+        require(
+            _delegateAddress != address(0),
+            "GaugeProxyV2: cannot delegate zero address"
+        );
+        require(
+            _delegateAddress != msg.sender,
+            "GaugeProxyV2: delegate address cannot be delegating"
+        );
+
+        delegateData storage _delegate = delegations[msg.sender];
+
+        uint256 currentPeriodId = getCurrentPeriodId();
+
+        address currentDelegate = _delegate.delegate;
+        _delegate.delegate = _delegateAddress;
+        _delegate.prevDelegate = currentDelegate;
+        _delegate.updatePeriodId = currentPeriodId;
+
+        if (_indefinite == true) {
+            _delegate.indefinite = true;
+        } else if (_delegate.prevDelegate == address(0)) {
+            _delegate.endPeriod = currentPeriodId + _periodsCount - 1;
+        } else {
+            _delegate.endPeriod = currentPeriodId + _periodsCount;
+        }
+    }
+
+    function voteFor(
+        address _owner,
+        address[] calldata _tokenVote,
+        int256[] calldata _weights
+    ) external {
+        require(
+            _tokenVote.length == _weights.length,
+            "GaugeProxy: token votes count does not match weights count"
+        );
+
+        uint256 currentId = getCurrentPeriodId();
+        require(currentId > 0, "Voting not started yet");
+        delegateData storage _delegate = delegations[_owner];
+        require(
+            (_delegate.delegate == msg.sender &&
+                currentId > _delegate.updatePeriodId) ||
+                (_delegate.prevDelegate == msg.sender &&
+                    currentId == _delegate.updatePeriodId) ||
+                (_delegate.prevDelegate == address(0) &&
+                    currentId == _delegate.updatePeriodId),
+            "Sender not authorized"
+        );
+        require(
+            _delegate.blockDelegate[currentId] == false,
+            "Delegating address has already voted"
+        );
+        require(
+            (_delegate.indefinite || currentId <= _delegate.endPeriod),
+            "Delegating period expired"
+        );
+
+        _vote(_owner, _tokenVote, _weights, currentId);
+    }
+
+    // Add new token gauge
+    function addGauge(address _token) external {
+        require(msg.sender == governance, "!gov");
+        require(
+            address(gaugeMiddleware) != address(0),
+            "cannot add new gauge without initializing gaugeMiddleware"
+        );
+        require(gauges[_token] == address(0x0), "exists");
+        string[] memory _rewardSymbols = new string[](1);
+        address[] memory _rewardTokens = new address[](1);
+        _rewardSymbols[0] = "PICKLE";
+        _rewardTokens[0] = address(PICKLE);
+        gauges[_token] = gaugeMiddleware.addGauge(
+            _token,
+            governance,
+            _rewardSymbols,
+            _rewardTokens
+        );
+        _tokens.push(_token);
+    }
+
+    // Add new token virtual gauge
+    function addVirtualGauge(address _token, address _jar) external {
+        require(msg.sender == governance, "!gov");
+        require(
+            address(virtualGaugeMiddleware) != address(0),
+            "cannot add new gauge without initializing gaugeMiddleware"
+        );
+        require(gauges[_token] == address(0x0), "exists");
+        string[] memory _rewardSymbols = new string[](1);
+        address[] memory _rewardTokens = new address[](1);
+        _rewardSymbols[0] = "PICKLE";
+        _rewardTokens[0] = address(PICKLE);
+        address vgauge = virtualGaugeMiddleware.addVirtualGauge(
+            _jar,
+            governance,
+            _rewardSymbols,
+            _rewardTokens
+        );
+        gauges[_token] = vgauge;
+        isVirtualGauge[vgauge] = true;
+        _tokens.push(_token);
+    }
+
+    function delistGauge(address _token) external {
+        require(msg.sender == governance, "!gov");
+        require(gauges[_token] != address(0x0), "!exists");
+
+        uint256 currentId = getCurrentPeriodId();
+        require(distributionId == currentId, "! all distributions completed");
+
+        address _gauge = gauges[_token];
+
+        require(gaugeWithNegativeWeight[_gauge] >= 5, "censors < 5");
+
+        delete isVirtualGauge[_gauge];
+        delete gauges[_token];
+
+        uint256 tokensLength = _tokens.length;
+        address[] memory newTokenArray = new address[](tokensLength - 1);
+
+        uint256 j = 0;
+        for (uint256 i = 0; i < tokensLength; i++) {
+            if (_tokens[i] != _token) {
+                newTokenArray[j] = _tokens[i];
+                j++;
+            }
+        }
+
+        _tokens = newTokenArray;
+    }
+
+    // Sets MasterChef PID
+    function setPID(uint256 _pid) external {
+        require(msg.sender == governance, "!gov");
+        require(pid == 0, "pid has already been set");
+        require(_pid > 0, "invalid pid");
+        pid = _pid;
+    }
+
+    // Deposits mDILL into MasterChef
+    function deposit() public {
+        require(pid > 0, "pid not initialized");
+        IERC20 _token = TOKEN;
+        uint256 _balance = _token.balanceOf(address(this));
+        _token.safeApprove(address(MASTER), 0);
+        _token.safeApprove(address(MASTER), _balance);
+        MASTER.deposit(pid, _balance);
+    }
+
+    // Fetches Pickle
+    function collect() public {
+        (uint256 _locked, ) = MASTER.userInfo(pid, address(this));
+        MASTER.withdraw(pid, _locked);
+        deposit();
+    }
+
+    function length() external view returns (uint256) {
+        return _tokens.length;
+    }
+
+    function distribute(uint256 _start, uint256 _end) external {
+        require(_start < _end, "GaugeProxyV2: bad _start");
+        require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
+        require(
+            msg.sender == governance,
+            "GaugeProxyV2: only governance can distribute"
+        );
+
+        uint256 currentId = getCurrentPeriodId();
+        require(
+            distributionId < currentId,
+            "GaugeProxyV2: all period distributions complete"
+        );
+
+        uint256 periodToUse = 0;
+        if (periodForDistribute[distributionId] == 0) {
+            // If period does not exist means no votes in this period
+            // Use previous period's votes and update dist. period
+            periodToUse = periodForDistribute[distributionId - 1];
+            periodForDistribute[distributionId] = periodForDistribute[
+                distributionId - 1
+            ];
+        } else {
+            periodToUse = periodForDistribute[distributionId];
+        }
+
+        collect();
+        int256 _balance = int256(PICKLE.balanceOf(address(this)));
+        int256 _totalWeight = totalWeight[periodToUse];
+
+        if (_balance > 0 && _totalWeight > 0) {
+            for (uint256 i = _start; i < _end; i++) {
+                if (distributed[distributionId][i]) {
+                    continue;
+                }
+                address _token = _tokens[i];
+                address _gauge = gauges[_token];
+                int256 _reward = (_balance * weights[periodToUse][_token]) /
+                    _totalWeight;
+                if (_reward > 0) {
+                    uint256 reward_ = uint256(_reward);
+                    uint256[] memory rewardArr = new uint256[](1);
+                    rewardArr[0] = reward_;
+
+                    PICKLE.safeApprove(_gauge, 0);
+                    PICKLE.safeApprove(_gauge, reward_);
+
+                    iGaugeV2(_gauge).notifyRewardAmount(rewardArr);
+                }
+
+                if (_reward < 0) {
+                    gaugeWithNegativeWeight[_gauge] += 1;
+                }
+                distributed[distributionId][i] = true;
+            }
+        }
+        if (_tokens.length == _end) {
+            distributionId += 1;
+        }
+    }
+}
diff --git a/src/dill/gauge-proxy.sol b/src/dill/gauge-proxy.sol
index 6b7888bf7..8064a5d4f 100644
--- a/src/dill/gauge-proxy.sol
+++ b/src/dill/gauge-proxy.sol
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.6.7; //^0.7.5;
+pragma experimental ABIEncoderV2;
 
 library SafeMath {
     function add(uint a, uint b) internal pure returns (uint) {
diff --git a/src/dill/scripts/deploy_gauge_proxy_V2.js b/src/dill/scripts/deploy_gauge_proxy_V2.js
new file mode 100644
index 000000000..a1e2935c1
--- /dev/null
+++ b/src/dill/scripts/deploy_gauge_proxy_V2.js
@@ -0,0 +1,29 @@
+const { ethers, upgrades } = require("hardhat");
+/**
+ * not working on mainnet fork, tested on mumbai 
+ */
+async function main() {
+  console.log("Getting contract...");
+  const gaugeProxyV2 = await ethers.getContractFactory(
+    "contracts/gauge-proxy-v2.sol:GaugeProxyV2"
+  );
+  console.log("Deploying GaugeProxyV2...");
+  const GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, {
+    initializer: "initialize",
+  });
+  await GaugeProxyV2.deployed();
+  console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+  // const GaugeProxyV2 = gaugeProxyV2.attach(
+  //   "0xc6f33472A3d0E3450bd866Bf7286e5EF6dbD0157"
+  // );
+  // console.log(await GaugeProxyV2.test());
+  // const pickle = await GaugeProxyV2.PICKLE();
+  // console.log(pickle);
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/src/dill/scripts/upgrade_gauge_proxy_v2.js b/src/dill/scripts/upgrade_gauge_proxy_v2.js
new file mode 100644
index 000000000..cd3de8c40
--- /dev/null
+++ b/src/dill/scripts/upgrade_gauge_proxy_v2.js
@@ -0,0 +1,25 @@
+const { ethers, upgrades } = require("hardhat");
+
+async function main() {
+  console.log("Getting contract...");
+  const GaugeProxyV2 = await ethers.getContractFactory(
+    "contracts/gauge-proxy-v2.sol:GaugeProxyV2"
+  );
+  console.log("Upgrading GaugeProxy...");
+  const upgrade = await upgrades.upgradeProxy(
+    "0xc6f33472A3d0E3450bd866Bf7286e5EF6dbD0157", // address of proxy deployed
+    GaugeProxyV2
+  );
+  console.log("gaugeProxy upgraded");
+  console.log(await upgrade.test());
+  const pickle = await upgrade.PICKLE();
+  console.log(pickle);
+}
+
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
new file mode 100644
index 000000000..3536927c5
--- /dev/null
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -0,0 +1,275 @@
+const {advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+const zeroAddr = "0x0000000000000000000000000000000000000000";
+let GaugeProxyV2, userSigner, populatedTx, masterChef, GaugeMiddleware;
+
+describe("Vote & Distribute : chunk and onlyGov distribution", () => {
+  before("Setting up gaugeProxyV2", async () => {
+    /**
+     *  sending gas cost to gov
+     * */
+    const signer = ethers.provider.getSigner();
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"), // 1000 ETH
+      data: undefined,
+    });
+
+    /** unlock governance account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    /** unlock user's account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    userSigner = ethers.provider.getSigner(userAddr);
+    masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+
+    // getting block timestamp
+    const blockNumBefore = await ethers.provider.getBlockNumber();
+    const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+    const timestampBefore = blockBefore.timestamp;
+    console.log(timestampBefore);
+
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [timestampBefore + 86400 * 7], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+
+    populatedTx = await masterChef.populateTransaction.add(5000000, mDILLAddr, false);
+    await governanceSigner.sendTransaction(populatedTx);
+
+    console.log("-- Deploying GaugeMiddleware contract --");
+    const gaugeMiddleware = await ethers.getContractFactory(
+      "/src/dill/gauge-middleware.sol:GaugeMiddleware",
+      governanceSigner
+    );
+
+    /** Deploy gaugeMiddleware should fail */
+    await expect(
+      upgrades.deployProxy(gaugeMiddleware, [governanceAddr, governanceAddr], {
+        initializer: "initialize",
+      })
+    ).to.be.revertedWith("_governance address and _gaugeProxy cannot be same");
+
+    /** Deploy gaugeMiddleware should fail */
+    await expect(
+      upgrades.deployProxy(gaugeMiddleware, [zeroAddr, governanceAddr], {
+        initializer: "initialize",
+      })
+    ).to.be.revertedWith("_gaugeProxy address cannot be set to zero");
+
+    /** Deploy gaugeMiddleware successfully */
+    GaugeMiddleware = await upgrades.deployProxy(gaugeMiddleware, [masterChefAddr, governanceAddr], {
+      initializer: "initialize",
+    });
+    await GaugeMiddleware.deployed();
+    console.log("gaugeMiddleware deployed at", GaugeMiddleware.address);
+  });
+
+  beforeEach(async () => {
+    console.log("Current Id => ", Number(await GaugeProxyV2.getCurrentPeriodId()));
+    console.log("Distribution Id => ", Number(await GaugeProxyV2.distributionId()));
+  });
+  it("change gauge gaugeProxy in middleware and add gauges successfully", async () => {
+    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    await expect(GaugeMiddleware.connect(userSigner).changeGaugeProxy(GaugeProxyV2.address)).to.be.revertedWith(
+      "can only be called by governance"
+    );
+
+    await GaugeMiddleware.connect(governanceSigner).changeGaugeProxy(GaugeProxyV2.address);
+
+    /** add gaugeMiddleware*/
+    console.log("-- Adding Gauge middleWare --");
+
+    await expect(GaugeProxyV2.addGaugeMiddleware(zeroAddr)).to.be.revertedWith("gaugeMiddleware cannot set to zero");
+    await GaugeProxyV2.connect(governanceSigner).addGaugeMiddleware(GaugeMiddleware.address);
+    await expect(GaugeProxyV2.addGaugeMiddleware(GaugeMiddleware.address)).to.be.revertedWith(
+      "current and new gaugeMiddleware are same"
+    );
+
+    await expect(GaugeProxyV2.addGauge(zeroAddr)).to.be.revertedWith("address of token cannot be zero");
+
+    await expect(GaugeMiddleware.addGauge(zeroAddr, governanceAddr, ["PICKLE"], [pickleAddr])).to.be.revertedWith(
+      "can only be called by gaugeProxy"
+    );
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addGauge(pickleLP);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addGauge(pyveCRVETH);
+
+    console.log("tokens length", Number(await GaugeProxyV2.length()));
+  });
+  it("Should successfully test first voting", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userSigner);
+    console.log("-- Voting on LP Gauge with 100% weight --");
+
+    await expect(
+      gaugeProxyFromUser.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Voting not started yet");
+
+    await expect(gaugeProxyFromUser.reset()).to.be.revertedWith("Voting not started");
+
+    advanceSevenDays();
+    console.log("Current Id => ", Number(await GaugeProxyV2.getCurrentPeriodId()));
+    console.log("Distribution Id => ", Number(await GaugeProxyV2.distributionId()));
+
+    populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+      gasLimit: 9000000,
+    });
+    await userSigner.sendTransaction(populatedTx);
+
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
+
+    // Adjusts _owner's votes according to latest _owner's DILL balance
+    await GaugeProxyV2.poke(userAddr);
+    const tokensAry = await GaugeProxyV2.tokens();
+
+    console.log("users pickleLP votes =>", await GaugeProxyV2.votes(userAddr, tokensAry[0]));
+    console.log("users pyveCRVETH votes =>", await GaugeProxyV2.votes(userAddr, tokensAry[1]));
+
+    //reset users vote
+    await gaugeProxyFromUser.reset();
+    let pickleLPVotes = await GaugeProxyV2.votes(userAddr, tokensAry[0]);
+    let pyveCRVETHVotes = await GaugeProxyV2.votes(userAddr, tokensAry[1]);
+    expect(pickleLPVotes).to.equal(0);
+    expect(pyveCRVETHVotes).to.equal(0);
+
+    // vote again
+    await gaugeProxyFromUser.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+      gasLimit: 9000000,
+    });
+    pickleLPVotes = await GaugeProxyV2.votes(userAddr, pickleLP);
+    pyveCRVETHVotes = await GaugeProxyV2.votes(userAddr, pyveCRVETH);
+    expect(Number(pickleLPVotes)).to.greaterThan(0);
+    expect(Number(pyveCRVETHVotes)).to.greaterThan(0);
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+  });
+
+  it("OnlyGov : distribution by non-gov address Should fail", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.distribute(0, 2);
+    await expect(userSigner.sendTransaction(populatedTx)).to.be.revertedWith(
+      "GaugeProxyV2: only governance can distribute"
+    );
+  });
+
+  it("Distribute(onlyGov) PICKLE to gauges Should fail as voting still in progress", async () => {
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
+  });
+
+  it("Distribution Should fail when end greater than token[] length is passed ", async () => {
+    await advanceSevenDays();
+    await expect(GaugeProxyV2.distribute(0, 3)).to.be.revertedWith("GaugeProxyV2: bad _end");
+  });
+
+  it("Successfully Distribute PICKLE(in chunks) to gauges in chunks after advancing 7 days", async () => {
+    /**
+     * FIRST CHUNK DISTRIBUTION (successful)
+     */
+    console.log("-- Distributing first chunk (0,1) --");
+    await GaugeProxyV2.distribute(0, 1, {
+      gasLimit: 900000,
+    });
+
+    let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    let pickleRewards = Number(await pickle.balanceOf(pickleGaugeAddr));
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = Number(await pickle.balanceOf(yvecrvGaugeAddr));
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+    expect(pickleRewards).to.greaterThan(0);
+    expect(yvecrvRewards).to.equal(0);
+  });
+
+  it("Should not distribute rewards to gauges when tried to distribute same chunk again", async () => {
+    /**
+     * FIRST CHUNK DISTRIBUTION (fail)
+     */
+    console.log("Distributing first chunk(0, 1) again");
+    await GaugeProxyV2.distribute(0, 1, {
+      gasLimit: 900000,
+    });
+
+    let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+  });
+
+  it("Should fail when tried to pass wrong start", async () => {
+    /**
+     * SECOND CHUNK DISTRIBUTION (fail)
+     */
+    console.log("--Distributing chunk with wrong start--");
+    await expect(GaugeProxyV2.distribute(2, 2)).to.be.revertedWith("GaugeProxyV2: bad _start");
+  });
+
+  it("Successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
+    /**
+     * SECOND CHUNK DISTRIBUTION (successful)
+     */
+    console.log("--Distributing second chunk(0,2)--");
+    await GaugeProxyV2.distribute(1, 2, {
+      gasLimit: 900000,
+    });
+    let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    let pickleRewards = Number(await pickle.balanceOf(pickleGaugeAddr));
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = Number(await pickle.balanceOf(yvecrvGaugeAddr));
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+    expect(yvecrvRewards).to.greaterThan(0);
+  });
+});
diff --git a/src/tests/dill/02_gaugeProxyV2_periodization.test.js b/src/tests/dill/02_gaugeProxyV2_periodization.test.js
new file mode 100644
index 000000000..871aa699a
--- /dev/null
+++ b/src/tests/dill/02_gaugeProxyV2_periodization.test.js
@@ -0,0 +1,203 @@
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+const {advanceSevenDays} = require("./testHelper");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+let GaugeProxyV2, userSigner, populatedTx, masterChef;
+
+describe("Vote & Distribute", () => {
+  before("Setting up gaugeProxyV2", async () => {
+    /**
+     *  sending gas cost to gov
+     * */
+    const signer = ethers.provider.getSigner();
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"), // 1000 ETH
+      data: undefined,
+    });
+
+    /** unlock governance account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    userSigner = ethers.provider.getSigner(userAddr);
+    masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+    // getting timestamp
+    const blockNumBefore = await ethers.provider.getBlockNumber();
+    const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+    const timestampBefore = blockBefore.timestamp;
+
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [timestampBefore], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+    let populatedTx;
+    populatedTx = await masterChef.populateTransaction.add(
+      5000000,
+      mDILLAddr,
+      false
+      // { gasLimit: 9000000 }
+    );
+    await governanceSigner.sendTransaction(populatedTx);
+
+    /** Deploy gaugeMiddleware */
+    console.log("-- Deploying GaugeMiddleware contract --");
+    const gaugeMiddleware = await ethers.getContractFactory(
+      "/src/dill/gauge-middleware.sol:GaugeMiddleware",
+      governanceSigner
+    );
+    const GaugeMiddleware = await upgrades.deployProxy(gaugeMiddleware, [GaugeProxyV2.address, governanceAddr], {
+      initializer: "initialize",
+    });
+    await GaugeMiddleware.deployed();
+    console.log("gaugeMiddleware deployed at", GaugeMiddleware.address);
+
+    /** add gaugeMiddleware*/
+    console.log("-- Adding Gauge middleWare --");
+    await GaugeProxyV2.addGaugeMiddleware(GaugeMiddleware.address);
+
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addGauge(pickleLP);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addGauge(pyveCRVETH);
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
+  });
+
+  beforeEach(async () => {
+    console.log("Current Id => ", Number(await GaugeProxyV2.getCurrentPeriodId()));
+    console.log("Distribution Id => ", Number(await GaugeProxyV2.distributionId()));
+  });
+  it("Should vote successfully (first voting)", async () => {
+    console.log("-- Voting on LP Gauge with 100% weight --");
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+      gasLimit: 9000000,
+    });
+    await userSigner.sendTransaction(populatedTx);
+
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+  });
+
+  it("Distribution(initial) should fail as voting for current(initial) period is still in progress", async () => {
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
+  });
+
+  it("Successfully Distribute(initial) PICKLE to gauges after advancing 7 days", async () => {
+    await advanceSevenDays();
+    await GaugeProxyV2.distribute(0, 2);
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    let pickleRewards = Number(await pickle.balanceOf(pickleGaugeAddr));
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = Number(await pickle.balanceOf(yvecrvGaugeAddr));
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+    expect(pickleRewards).to.greaterThan(0);
+    expect(yvecrvRewards).to.greaterThan(0);
+  });
+
+  it("Distribute should fail as all distributions are complete ", async () => {
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
+  });
+
+  it("Should distribute similar rewards for the periods users have not voted for (advancing 3 weeks)", async () => {
+    await advanceSevenDays();
+    await advanceSevenDays();
+    await advanceSevenDays();
+    console.log("--Advanced 3 weeks--");
+
+    const cid = await GaugeProxyV2.getCurrentPeriodId();
+    const did = await GaugeProxyV2.distributionId();
+
+    console.log("Current Id =>", Number(cid));
+    console.log("Distribution Id =>", Number(did));
+
+    for (let i = did; i < cid; i++) {
+      console.log("Distributing for id => ", i);
+      await GaugeProxyV2.distribute(0, 2);
+      const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+      const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+      const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+      const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+      console.log("Rewards to Pickle gauge", pickleRewards.toString());
+
+      const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+      console.log("Rewards to pyveCRV gauge", yvecrvRewards.toString());
+    }
+  });
+
+  it("Distribute should fail as all distributions are complete ", async () => {
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
+  });
+
+  it("Should vote successfully (second voting)", async () => {
+    console.log("-- Voting on LP Gauge with 100% weight --");
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+      gasLimit: 9000000,
+    });
+    await userSigner.sendTransaction(populatedTx);
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+  });
+
+  it("Successfully Distribute PICKLE to gauges after advancing 7 days", async () => {
+    await advanceSevenDays();
+    await GaugeProxyV2.distribute(0, 2);
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    let pickleRewards = Number(await pickle.balanceOf(pickleGaugeAddr));
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = Number(await pickle.balanceOf(yvecrvGaugeAddr));
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+    expect(pickleRewards).to.greaterThan(0);
+    expect(yvecrvRewards).to.greaterThan(0);
+  });
+
+  it("Distribute should fail as all distributions are complete ", async () => {
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
+  });
+});
diff --git a/src/tests/dill/03_gaugeProcyV2_delegation.test.js b/src/tests/dill/03_gaugeProcyV2_delegation.test.js
new file mode 100644
index 000000000..f253262da
--- /dev/null
+++ b/src/tests/dill/03_gaugeProcyV2_delegation.test.js
@@ -0,0 +1,177 @@
+const {expect} = require("chai");
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+
+const {advanceSevenDays} = require("./testHelper");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+let GaugeProxyV2, userSigner, populatedTx, masterChef, governanceSigner;
+
+describe("Vote & Distribute", () => {
+  before("Setting up gaugeProxyV2", async () => {
+    /**
+     *  sending gas cost to gov
+     * */
+    const signer = ethers.provider.getSigner();
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"), // 1000 ETH
+      data: undefined,
+    });
+
+    /** unlock governance account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
+    userSigner = ethers.provider.getSigner(userAddr);
+    masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+    // getting timestamp
+    const blockNumBefore = await ethers.provider.getBlockNumber();
+    const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+    const timestampBefore = blockBefore.timestamp;
+
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [timestampBefore], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+    let populatedTx;
+    populatedTx = await masterChef.populateTransaction.add(5000000, mDILLAddr, false);
+    await governanceSigner.sendTransaction(populatedTx);
+
+    /** Deploy gaugeMiddleware */
+    console.log("-- Deploying GaugeMiddleware contract --");
+    const gaugeMiddleware = await ethers.getContractFactory(
+      "/src/dill/gauge-middleware.sol:GaugeMiddleware",
+      governanceSigner
+    );
+    const GaugeMiddleware = await upgrades.deployProxy(gaugeMiddleware, [GaugeProxyV2.address, governanceAddr], {
+      initializer: "initialize",
+    });
+    await GaugeMiddleware.deployed();
+    console.log("gaugeMiddleware deployed at", GaugeMiddleware.address);
+
+    /** add gaugeMiddleware*/
+    console.log("-- Adding Gauge middleWare --");
+    await GaugeProxyV2.addGaugeMiddleware(GaugeMiddleware.address);
+
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addGauge(pickleLP);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addGauge(pyveCRVETH);
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
+  });
+  beforeEach(async () => {
+    console.log("Current Id => ", Number(await GaugeProxyV2.getCurrentPeriodId()));
+    console.log("Distribution Id => ", Number(await GaugeProxyV2.distributionId()));
+  });
+  it("Should set delegate successfully", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(governanceAddr, 2, false);
+    await userSigner.sendTransaction(populatedTx);
+  });
+
+  it("delegate vote should fail as votes count does not match weights count", async () => {
+    /** here gov will vote on behalf of user */
+    await expect(GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000])).to.be.revertedWith(
+      "token votes count does not match weights count"
+    );
+  });
+
+  it("delegate should vote successfully", async () => {
+    /** here gov will vote on behalf of user */
+    GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000]);
+  });
+
+  it("successfully Distribute after advancing 7 days", async () => {
+    await advanceSevenDays();
+    await GaugeProxyV2.distribute(0, 2);
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge => ", pickleRewards.toString());
+
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+  });
+
+  it("delegate should vote again successfully ", async () => {
+    /** here gov will vote on behalf of user */
+    await GaugeProxyV2.connect(governanceSigner).voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000]);
+  });
+  it("user must successfully overwrite his votes after delegate has voted ", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+      gasLimit: 9000000,
+    });
+    await userSigner.sendTransaction(populatedTx);
+  });
+  it("delegate should not be able to vote if owner has already voted for current period", async () => {
+    await expect(
+      GaugeProxyV2.connect(governanceSigner).voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000])
+    ).to.be.revertedWith("Delegating address has already voted");
+  });
+  it("Successfully Distribute PICKLE to gauges advancing 7 days", async () => {
+    await advanceSevenDays();
+    await GaugeProxyV2.distribute(0, 2);
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge => ", pickleRewards.toString());
+
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+  });
+
+  it("Delegate vote should fail for user as delegation period has expired", async () => {
+    /** here gov will vote on behalf of user */
+    await expect(
+      GaugeProxyV2.connect(governanceSigner).voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000])
+    ).to.be.revertedWith("Delegating period expired");
+  });
+  it("Should reset delegate successfully and again reset to indefinite", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(dillHolder, 2, false);
+    await userSigner.sendTransaction(populatedTx);
+
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(dillHolder, 2, true);
+    await userSigner.sendTransaction(populatedTx);
+  });
+});
diff --git a/src/tests/dill/04_gaugeProxyV2_censorship.test.js b/src/tests/dill/04_gaugeProxyV2_censorship.test.js
new file mode 100644
index 000000000..9de11444f
--- /dev/null
+++ b/src/tests/dill/04_gaugeProxyV2_censorship.test.js
@@ -0,0 +1,298 @@
+const {expect} = require("chai");
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+const {advanceSevenDays} = require("./testHelper");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+const dillHolder1Addr = "0x9d074e37d408542fd38be78848e8814afb38db17";
+const dillHolder2Addr = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+const dillHolder3Addr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
+
+let GaugeProxyV2, userSigner, populatedTx, masterChef, pickle;
+
+describe("vote & distribute", () => {
+  before("setting up gaugeProxyV2", async () => {
+    /**
+     *  sending gas cost to gov
+     * */
+    const signer = ethers.provider.getSigner();
+
+    console.log((await signer.getBalance()).toString());
+
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    await signer.sendTransaction({
+      to: dillHolder1Addr,
+      value: ethers.BigNumber.from("1000000000000000000"),
+      data: undefined,
+    });
+    await signer.sendTransaction({
+      to: dillHolder2Addr,
+      value: ethers.BigNumber.from("1000000000000000000"),
+      data: undefined,
+    });
+    await signer.sendTransaction({
+      to: dillHolder3Addr,
+      value: ethers.BigNumber.from("1000000000000000000"),
+      data: undefined,
+    });
+    /** unlock governance account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    /** unlock dill holders accounts */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder1Addr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder2Addr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder3Addr],
+    });
+
+    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    userSigner = ethers.provider.getSigner(userAddr);
+    masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+    console.log("Deploying GaugeProxyV2...");
+    // getting timestamp
+    const blockNumBefore = await ethers.provider.getBlockNumber();
+    const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+    const timestampBefore = blockBefore.timestamp;
+
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [timestampBefore], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    /** Add mDILL to MasterChef */
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+    let populatedTx;
+    populatedTx = await masterChef.populateTransaction.add(
+      5000000,
+      mDILLAddr,
+      false
+      // { gasLimit: 9000000 }
+    );
+    await governanceSigner.sendTransaction(populatedTx);
+
+    /** Deploy gaugeMiddleware */
+    console.log("-- Deploying GaugeMiddleware contract --");
+    const gaugeMiddleware = await ethers.getContractFactory(
+      "/src/dill/gauge-middleware.sol:GaugeMiddleware",
+      governanceSigner
+    );
+
+    const GaugeMiddleware = await upgrades.deployProxy(gaugeMiddleware, [GaugeProxyV2.address, governanceAddr], {
+      initializer: "initialize",
+    });
+    await GaugeMiddleware.deployed();
+    console.log("gaugeMiddleware deployed at", GaugeMiddleware.address);
+
+    /** add gaugeMiddleware*/
+    await GaugeProxyV2.addGaugeMiddleware(GaugeMiddleware.address);
+
+    /** add gauge*/
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addGauge(pickleLP);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addGauge(pyveCRVETH);
+
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
+
+    pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+    // dill = await ethers.getContractAt("src/DillABI:dillAbi", dillAddr);
+    // console.log(await dill.totalSupply());
+  });
+
+  it("should vote successfully with -ve votes(first voting)", async () => {
+    console.log("-- Voting on LP Gauge with negative weight --");
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [-4000000, 6000000], {
+      gasLimit: 9000000,
+    });
+    await userSigner.sendTransaction(populatedTx);
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+  });
+
+  it("successfully Distribute(initial) PICKLE to gauges advancing 7 days", async () => {
+    await advanceSevenDays();
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+
+    await GaugeProxyV2.distribute(0, 2);
+
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+  });
+
+  it("Should test total aggregate voting successfully", async () => {
+    const dillHolder1 = ethers.provider.getSigner(dillHolder1Addr);
+    const dillHolder2 = ethers.provider.getSigner(dillHolder2Addr);
+    const dillHolder3 = ethers.provider.getSigner(dillHolder3Addr);
+    // GaugeProxyV2 by user
+    const GaugeV2By1 = GaugeProxyV2.connect(dillHolder1);
+    const GaugeV2By2 = GaugeProxyV2.connect(dillHolder2);
+    const GaugeV2By3 = GaugeProxyV2.connect(dillHolder3);
+
+    // vote by Luffy
+    console.log("-- Voting on LP Gauge with by Luffy --");
+    populatedTx = await GaugeV2By1.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder1.sendTransaction(populatedTx);
+
+    // vote by Zoro
+    console.log("-- Voting on LP Gauge with by Zoro --");
+    populatedTx = await GaugeV2By2.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -4000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder2.sendTransaction(populatedTx);
+
+    //1 vote by Sanji
+    console.log("-- Voting on LP Gauge with by Sanji --");
+    populatedTx = await GaugeV2By3.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder3.sendTransaction(populatedTx);
+
+    await advanceSevenDays();
+    //2
+    console.log("-- Voting on LP Gauge with by Sanji --");
+    populatedTx = await GaugeV2By3.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder3.sendTransaction(populatedTx);
+
+    await advanceSevenDays();
+    //3
+    console.log("-- Voting on LP Gauge with negative weight by Sanji --");
+    populatedTx = await GaugeV2By3.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder3.sendTransaction(populatedTx);
+
+    await advanceSevenDays();
+    //4
+    console.log("-- Voting on LP Gauge with negative weight by Sanji --");
+    populatedTx = await GaugeV2By3.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder3.sendTransaction(populatedTx);
+
+    await advanceSevenDays();
+    //5
+    console.log("-- Voting on LP Gauge with negative weight by Sanji --");
+    populatedTx = await GaugeV2By3.populateTransaction.vote([pickleLP, pyveCRVETH], [4000000, -1000000], {
+      gasLimit: 9000000,
+    });
+    await dillHolder3.sendTransaction(populatedTx);
+
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+
+    // console.log("Total weight =>",Number(await GaugeProxyV2.totalWeight(1)));
+    // rewards to Pickle gauge 79936051158800000
+    // rewards to pyveCRV gauge 119904076738200000
+    // rewards to pyveCRV gauge 177537555187922547
+    // distribute
+
+    await advanceSevenDays();
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+  });
+  it("Should successfully test delist gauge", async () => {
+    const dillHolder3 = ethers.provider.getSigner(dillHolder3Addr);
+    await expect(GaugeProxyV2.delistGauge(masterChefAddr)).to.be.revertedWith("!exists");
+    await expect(GaugeProxyV2.connect(dillHolder3).delistGauge(pyveCRVETH)).to.be.revertedWith("!gov");
+    await expect(GaugeProxyV2.delistGauge(pyveCRVETH)).to.be.revertedWith("! all distributions completed");
+
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+    console.log("-- Distributing 5 times -- ");
+    await GaugeProxyV2.distribute(0, 2);
+    await GaugeProxyV2.distribute(0, 2);
+    await GaugeProxyV2.distribute(0, 2);
+    await GaugeProxyV2.distribute(0, 2);
+    await GaugeProxyV2.distribute(0, 2);
+
+    await expect(GaugeProxyV2.delistGauge(pickleLP)).to.be.revertedWith("censors < 5");
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+
+    const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+
+    console.log(
+      "-- pickleLP gauge with -ve weight ",
+      Number(await GaugeProxyV2.gaugeWithNegativeWeight(pickleGaugeAddr))
+    );
+    console.log(
+      "-- pyveCRVETH gauge with -ve weight ",
+      Number(await GaugeProxyV2.gaugeWithNegativeWeight(yvecrvGaugeAddr))
+    );
+
+    console.log("-- Removing gauge with -ve aggregate voting > 5 --");
+    await GaugeProxyV2.delistGauge(pyveCRVETH);
+  });
+});
diff --git a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
new file mode 100644
index 000000000..bc708d780
--- /dev/null
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -0,0 +1,538 @@
+const {advanceNDays, advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers} = require("hardhat");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const userAddr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+let userSigner,
+  GaugeV2,
+  thisContractAddr,
+  GaugeFromUser,
+  pickle,
+  pickleHolderSigner,
+  governanceSigner,
+  dillHolderSigner,
+  gaugeFromDillHolder,
+  Luffy,
+  Zoro,
+  Sanji,
+  Nami,
+  userWithNoPickleOrDill;
+const fivePickle = ethers.utils.parseEther("5");
+
+const printStakes = async (address) => {
+  let stakes = await GaugeV2.lockedStakesOf(address);
+  console.log("********************* Locked stakes ********************************************");
+  stakes.forEach((stake, index) => {
+    console.log(
+      "Liquidity in stake ",
+      index,
+      ethers.utils.formatEther(stake.liquidity),
+      "ending timestamp",
+      stake.ending_timestamp,
+      "are",
+      stake.isPermanentlyLocked ? "locked" : "unlocked"
+    );
+  });
+  console.log("*******************************************************************************");
+};
+
+describe("Liquidity Staking tests", () => {
+  before("Setting up gaugeV2", async () => {
+    const signer = ethers.provider.getSigner();
+    pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    userSigner = ethers.provider.getSigner(userAddr);
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
+    [Luffy, Zoro, Sanji, Nami, userWithNoPickleOrDill] = await ethers.getSigners();
+
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("-- Sending gas cost to dillHolder addr --");
+    await signer.sendTransaction({
+      to: dillHolder,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("------------------------ sent ------------------------");
+
+    /** unlock accounts */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [pickleHolder],
+    });
+
+    pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    console.log("-- Deploying Gaugev2 contract --");
+    const gaugeV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeV2", pickleHolderSigner);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, pickleHolder, ["PICKLE"], [pickleAddr]);
+    await GaugeV2.deployed();
+    thisContractAddr = GaugeV2.address;
+    console.log("GaugeV2 deployed to:", thisContractAddr);
+
+    GaugeFromUser = GaugeV2.connect(userSigner);
+    const pickleFromHolder = pickle.connect(pickleHolderSigner);
+
+    dillHolderSigner = ethers.provider.getSigner(dillHolder);
+    gaugeFromDillHolder = GaugeV2.connect(dillHolderSigner);
+
+    console.log("------------------------ Depositing pickle ------------------------");
+    await pickleFromHolder.transfer(dillHolder, ethers.utils.parseEther("100"));
+    await pickleFromHolder.transfer(userAddr, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Luffy.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Zoro.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Sanji.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Nami.address, ethers.utils.parseEther("10"));
+    console.log("------------------------       Done        ------------------------");
+  });
+
+  it("Should fail to stake when trying to stake for less than minimum time", async () => {
+    await expect(GaugeFromUser.depositAllAndLock(8640, false, {gasLimit: 9000000})).to.be.revertedWith(
+      "Minimum stake time not met"
+    );
+  });
+
+  it("Should fail to stake when trying to stake for more than maximum time", async () => {
+    await pickle.connect(userSigner).approve(thisContractAddr, 0);
+    await pickle.connect(userSigner).approve(thisContractAddr, 100000);
+    await expect(GaugeFromUser.depositAllAndLock(86400 * 366, false, {gasLimit: 9000000})).to.be.revertedWith(
+      "Trying to lock for too long"
+    );
+  });
+
+  it("Should fail to stake when trying to stake 0 liquidity", async () => {
+    await pickle.connect(userSigner).approve(thisContractAddr, 0);
+    await pickle.connect(userSigner).approve(thisContractAddr, 100000);
+    await expect(GaugeFromUser.depositAndLock(0, 86400 * 360, false, {gasLimit: 9000000})).to.be.revertedWith(
+      "Cannot stake 0"
+    );
+  });
+
+  it("should stake successfully (first stake)", async () => {
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    console.log("-- User's Pickle balance --", Number(ethers.utils.formatEther(await pickle.balanceOf(userAddr))));
+    console.log(
+      "-- Contracts Pickle balance --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(thisContractAddr)))
+    );
+
+    await pickle.connect(userSigner).approve(thisContractAddr, 0);
+    await pickle.connect(userSigner).approve(thisContractAddr, ethers.utils.parseEther("10"));
+
+    await GaugeFromUser.depositAndLock(ethers.utils.parseEther("10"), 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+
+    console.log(
+      "-- User's Pickle balance after deposit --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(userAddr)))
+    );
+    console.log(
+      "-- Contracts Pickle balance after deposit --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(thisContractAddr)))
+    );
+  });
+
+  it("notifyRewardAmount should fail when called by other than distribution or wrong reward array is passed", async () => {
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
+    await expect(GaugeFromUser.notifyRewardAmount([bal], {gasLimit: 9000000})).to.be.revertedWith(
+      "Caller is not RewardsDistribution contract"
+    );
+
+    await expect(
+      GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal, bal], {gasLimit: 9000000})
+    ).to.be.revertedWith("Rewards count do not match reward token count");
+  });
+
+  it("Should get reward amount successfully", async () => {
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
+
+    await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal], {
+      gasLimit: 9000000,
+    });
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
+    advanceNDays(200);
+
+    console.log("--------------------------------------------------------------------------------------");
+    console.log(
+      "-- User's Pickle balance before claiming reward --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(userAddr)))
+    );
+    console.log(
+      "-- Contracts Pickle balance before claiming reward --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(thisContractAddr)))
+    );
+
+    console.log("--------------------------------------------------------------------------------------");
+    await GaugeFromUser.getReward({
+      gasLimit: 9000000,
+    });
+
+    console.log(
+      "-- User's Pickle balance after claiming reward --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(userAddr)))
+    );
+    console.log(
+      "-- Contracts Pickle balance after claiming reward --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(thisContractAddr)))
+    );
+    console.log("--------------------------------------------------------------------------------------");
+  });
+
+  it("Should fail to withdraw locked amount if stake is still locked", async () => {
+    await expect(GaugeFromUser.withdraw(0, {gasLimit: 9000000})).to.be.revertedWith("Stake is still locked!");
+  });
+
+  it("Should fail to withdraw locked amount if wrong stake index is passed ", async () => {
+    await expect(GaugeFromUser.withdraw(1, {gasLimit: 9000000})).to.be.revertedWith("Stake not found");
+  });
+
+  it("Should withdraw locked amount successfully", async () => {
+    advanceNDays(165);
+    await GaugeFromUser.withdraw(0, {
+      gasLimit: 9000000,
+    });
+    console.log(
+      "-- User's Pickle balance after withdraw --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(userAddr)))
+    );
+    console.log(
+      "-- Contracts Pickle balance after withdraw --",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(thisContractAddr)))
+    );
+  });
+
+  it("Should test deposit, deposit and lock, permanent lock and get reward successfully for dill holder and non-holder users", async () => {
+    console.log("===================================================================================================");
+    console.log("dillHolder's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolder))));
+    console.log("Luffy's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Zoro's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Zoro.address))));
+    console.log("Sanji's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address))));
+    console.log("Nami's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address))));
+    console.log("===================================================================================================");
+
+    // Deposit - dillHolder
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, fivePickle);
+    await gaugeFromDillHolder.deposit(fivePickle, {gasLimit: 9000000});
+    console.log(
+      "dillHolder's pickle balance after deposit",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolder)))
+    );
+
+    // Deposit and Lock - dillHolder
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, fivePickle);
+    await gaugeFromDillHolder.depositAndLock(fivePickle, 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+    console.log(
+      "dillHolder's pickle balance after deposit and lock",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolder)))
+    );
+
+    const gaugeFromLuffy = GaugeV2.connect(Luffy);
+    // Deposit - Luffy
+    await pickle.connect(Luffy).approve(thisContractAddr, 0);
+    await pickle.connect(Luffy).approve(thisContractAddr, fivePickle);
+    await gaugeFromLuffy.deposit(fivePickle, {gasLimit: 9000000});
+    console.log(
+      "Luffy's pickle balance after deposit",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+    );
+
+    // Deposit and Lock - Luffy
+    await pickle.connect(Luffy).approve(thisContractAddr, 0);
+    await pickle.connect(Luffy).approve(thisContractAddr, fivePickle);
+    await gaugeFromLuffy.depositAndLock(fivePickle, 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+    console.log(
+      "Luffy's pickle balance after deposit and lock",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+    );
+
+    advanceSevenDays();
+
+    // Deposit - Zoro
+    await pickle.connect(Zoro).approve(thisContractAddr, 0);
+    await pickle.connect(Zoro).approve(thisContractAddr, fivePickle);
+    await GaugeV2.connect(Zoro).deposit(fivePickle, {gasLimit: 9000000});
+    console.log(
+      "Zoro's pickle balance after deposit",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Zoro.address)))
+    );
+
+    advanceSevenDays();
+
+    // Deposit and Lock - Sanji
+    await pickle.connect(Sanji).approve(thisContractAddr, 0);
+    await pickle.connect(Sanji).approve(thisContractAddr, fivePickle);
+    await GaugeV2.connect(Sanji).depositAndLock(fivePickle, 86400 * 365, false, {gasLimit: 9000000});
+    console.log(
+      "Sanji's pickle balance after deposit and lock",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
+    );
+
+    // Deposit and Lock - Nami
+    await pickle.connect(Nami).approve(thisContractAddr, 0);
+    await pickle.connect(Nami).approve(thisContractAddr, fivePickle);
+    await GaugeV2.connect(Nami).depositAndLock(fivePickle, 86400 * 365, true, {
+      gasLimit: 9000000,
+    });
+    console.log(
+      "Nami's pickle balance after deposit and lock(permanent lock)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address)))
+    );
+
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
+    await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal], {
+      gasLimit: 9000000,
+    });
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
+    console.log("--------------------------------------------------------------------------------------");
+    advanceNDays(365);
+
+    // exit dillHolder
+    await gaugeFromDillHolder.exit({
+      gasLimit: 9000000,
+    });
+    console.log(
+      "dillHolder's pickle balance after getting reward and withdrawing deposit (deposit and deposit & lock)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolder)))
+    );
+
+    // exit Luffy
+    await gaugeFromLuffy.exit({
+      gasLimit: 9000000,
+    });
+    console.log(
+      "Luffy's pickle balance after getting reward and withdrawing deposit (deposit - no dill and deposit & lock)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+    );
+
+    advanceSevenDays();
+
+    // exit Zoro
+    await GaugeV2.connect(Zoro).exit({
+      gasLimit: 9000000,
+    });
+    console.log(
+      "Zoro's pickle balance after getting reward and withdrawing deposit (deposit)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Zoro.address)))
+    );
+    advanceSevenDays();
+
+    // exit Sanji
+    await GaugeV2.connect(Sanji).exit({
+      gasLimit: 9000000,
+    });
+    console.log(
+      "Sanji's pickle balance after getting reward and withdrawing deposit (deposit & lock)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
+    );
+
+    await printStakes(Nami.address);
+    //getReward Nami (permanent lock)
+    await GaugeV2.connect(Nami).getReward();
+    console.log(
+      "Nami's pickle balance after getting reward (2.5x because stakes are permanently locked)",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address)))
+    );
+    console.log("--------------------------------------------------------------------------------------");
+  });
+
+  it("Should test unlock stakes for account successfully", async () => {
+    await pickle.connect(userSigner).approve(thisContractAddr, 0);
+    await pickle.connect(userSigner).approve(thisContractAddr, ethers.utils.parseEther("0.03"));
+    const userBalBeforeDeposit = await pickle.balanceOf(userAddr);
+    await GaugeFromUser.depositAndLock(ethers.utils.parseEther("0.03"), 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+    const userBalAfterDeposit = await pickle.balanceOf(userAddr);
+    expect(userBalBeforeDeposit).not.to.be.eq(userBalAfterDeposit);
+
+    await expect(GaugeFromUser.withdraw(1, {gasLimit: 9000000})).to.be.revertedWith("Stake is still locked!");
+
+    await expect(GaugeFromUser.unlockStakeForAccount(userAddr, {gasLimit: 9000000})).to.be.revertedWith(
+      "Operation allowed by only governance"
+    );
+    await GaugeV2.connect(governanceSigner).unlockStakeForAccount(userAddr);
+
+    const isUnlocked = await GaugeV2.stakesUnlockedForAccount(userAddr);
+    expect(isUnlocked).to.be.eq(true);
+
+    await GaugeFromUser.exit({gasLimit: 9000000});
+  });
+  it("Test partial withdrawal", async () => {
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
+    const DillHolderPickleBalance = await pickle.connect(dillHolderSigner).balanceOf(dillHolder);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, DillHolderPickleBalance);
+    console.log(" -- deposit and lock 5 pickle for 3 days -- ");
+    await gaugeFromDillHolder.depositAndLock(fivePickle, 86400 * 3, false, {
+      gasLimit: 9000000,
+    });
+    console.log(" -- deposit and lock 5 pickle for 365 days -- ");
+    await gaugeFromDillHolder.depositAndLock(fivePickle, 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+    console.log(" -- deposit and lock 5 pickle 1 day -- ");
+    await gaugeFromDillHolder.depositAndLock(fivePickle, 86400, false, {
+      gasLimit: 9000000,
+    });
+    console.log(" -- deposit all remaining pickle -- ");
+    await gaugeFromDillHolder.depositAll({gasLimit: 9000000});
+
+    await printStakes(dillHolder);
+    advanceSevenDays();
+
+    await expect(gaugeFromDillHolder.partialWithdrawal(ethers.utils.parseEther("5000"))).to.be.revertedWith(
+      "Withdraw amount exceeds balance"
+    );
+
+    // Withdraw 5 pickle (= liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 5 pickle -- ");
+    await gaugeFromDillHolder.partialWithdrawal(fivePickle); // working fine
+
+    await printStakes(dillHolder);
+
+    // Withdraw 2 pickle (< liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 2 pickle -- ");
+    await gaugeFromDillHolder.partialWithdrawal(ethers.utils.parseEther("2")); // working fine
+
+    await printStakes(dillHolder);
+
+    // Withdraw 5 pickle (> liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 5 pickle -- ");
+    await gaugeFromDillHolder.partialWithdrawal(fivePickle);
+
+    await printStakes(dillHolder);
+  });
+  it("Should test unlock stakes and withdraw all", async () => {
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
+    const DillHolderPickleBalance = await pickle.connect(dillHolderSigner).balanceOf(dillHolder);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, DillHolderPickleBalance);
+    console.log("-- Permanently staking pickle --");
+    await gaugeFromDillHolder.depositAllAndLock(86400, true);
+
+    //print stakes
+    await printStakes(dillHolder);
+
+    console.log("-- unlocking all stakes --");
+    await expect(GaugeV2.unlockStakes()).to.be.revertedWith("Operation allowed by only governance");
+
+    //unlock all stakes
+    await GaugeV2.connect(governanceSigner).unlockStakes();
+
+    // withdraw all
+    console.log(" -- Withdrawing all unlocked stakes of dillHolder -- ");
+    await gaugeFromDillHolder.withdrawAll();
+
+    //print stakes
+    await printStakes(dillHolder);
+  });
+  it("Should check max lockMultiplier and rewardForDuration", async () => {
+    const multiplierFor1year = await GaugeV2.lockMultiplier(86400 * 365);
+    const multiplierFor2year = await GaugeV2.lockMultiplier(86400 * 365 * 2);
+    expect(multiplierFor1year).to.equal(multiplierFor2year);
+
+    const rewardForDuration = await GaugeV2.getRewardForDuration();
+    console.log("rewardForDuration => ", rewardForDuration);
+  });
+  it("Should set and test staking delegation successfully", async () => {
+    // console.log("Staking delegate => ", await GaugeV2.stakingDelegates(dillHolder,dillHolder));
+    // set delegate
+    await expect(gaugeFromDillHolder.setStakingDelegate(dillHolder)).to.be.revertedWith("Cannot delegate to self");
+
+    await gaugeFromDillHolder.setStakingDelegate(userWithNoPickleOrDill.address);
+    await expect(gaugeFromDillHolder.setStakingDelegate(userWithNoPickleOrDill.address)).to.be.revertedWith(
+      "Already a staking delegate for user!"
+    );
+
+    const DillHolderPickleBalance = await pickle.connect(dillHolderSigner).balanceOf(dillHolder);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, DillHolderPickleBalance);
+
+    await expect(
+      GaugeV2.connect(Luffy).depositFor(fivePickle, dillHolder, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Only registered delegates can deposit for their delegator");
+
+    await expect(
+      GaugeV2.connect(Luffy).depositForAndLock(fivePickle, dillHolder, 86400 * 365, false, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Only registered delegates can stake for their delegator");
+
+    await GaugeV2.connect(userWithNoPickleOrDill).depositFor(fivePickle, dillHolder, {
+      gasLimit: 9000000,
+    });
+    await GaugeV2.connect(userWithNoPickleOrDill).depositForAndLock(fivePickle, dillHolder, 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+  });
+  it("Should test setMultiplier successfully", async () => {
+    await expect(GaugeFromUser.setMultipliers(1, {gasLimit: 9000000})).to.be.revertedWith(
+      "Operation allowed by only governance"
+    );
+    await expect(
+      GaugeV2.connect(governanceSigner).setMultipliers(10 ** 14, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Multiplier must be greater than or equal to 1e18");
+    const newMultilier = ethers.BigNumber.from("10000000000000000000"); //new BigNumber(10 ** 19).toFixed();
+    await GaugeV2.connect(governanceSigner).setMultipliers(newMultilier, {
+      gasLimit: 9000000,
+    });
+    const maxMultiplier = await GaugeV2.lockMaxMultiplier();
+    expect(maxMultiplier).to.be.eq(newMultilier);
+  });
+  it("Should test setMaxRewardsDuration ", async () => {
+    await expect(GaugeFromUser.setMaxRewardsDuration(86400, {gasLimit: 9000000})).to.be.revertedWith(
+      "Operation allowed by only governance"
+    );
+    await expect(
+      GaugeV2.connect(governanceSigner).setMaxRewardsDuration(8640, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Rewards duration too short");
+    const newMaxTime = 86400 * 400;
+    await GaugeV2.connect(governanceSigner).setMaxRewardsDuration(newMaxTime, {
+      gasLimit: 9000000,
+    });
+    const maxTime = await GaugeV2.lockTimeForMaxMultiplier();
+    expect(newMaxTime).to.be.eq(maxTime);
+  });
+});
diff --git a/src/tests/dill/06_GaugeV2_situtational.test.js b/src/tests/dill/06_GaugeV2_situtational.test.js
new file mode 100644
index 000000000..d2b23a08c
--- /dev/null
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -0,0 +1,250 @@
+const {advanceNDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers} = require("hardhat");
+const chalk = require("chalk");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
+const dillHolderAddr = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+let GaugeV2,
+  thisContractAddr,
+  pickle,
+  pickleHolderSigner,
+  dillHolder,
+  pickleFromHolder,
+  Luffy,
+  Zoro,
+  Sanji,
+  Nami,
+  GaugeV2ByLuffy,
+  GaugeV2ByZoro,
+  GaugeV2BySanji,
+  GaugeV2ByNami,
+  GaugeV2BydillHolder;
+
+const tenPickles = ethers.utils.parseEther("10");
+const notifyRewardAmountMethod = async (print = true, days = 7) => {
+  advanceNDays(days);
+  // Execute notify reward amount
+  // console.log(chalk.blue("PickleHolder's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(pickleHolder)))));
+  let totalSupply = await GaugeV2.totalSupply();
+  print ? console.log(chalk.bold("-- -- executing notifyReward -- -- ")) : "";
+  print
+    ? console.log(chalk.blue("totalSupply pickle in contract =>", Number(ethers.utils.formatEther(totalSupply))))
+    : "";
+  await pickleFromHolder.approve(thisContractAddr, 0);
+  await pickleFromHolder.approve(thisContractAddr, totalSupply);
+  await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([totalSupply], {
+    gasLimit: 9000000,
+  });
+  print ? console.log("rewardRates =>", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0)))) : "";
+
+  // ***************** Luffy claims after every notify reward *****************
+  await getAndPrintReward("Luffy", GaugeV2ByLuffy, Luffy.address);
+};
+
+const getAndPrintReward = async (actor, gaugeByActor, address) => {
+  console.log("Derived supply = ", Number(ethers.utils.formatEther(await gaugeByActor.derivedSupply())));
+  console.log(
+    `derivedBalances[${actor}] = `,
+    Number(ethers.utils.formatEther(await gaugeByActor.derivedBalances(address)))
+  );
+  await gaugeByActor.getReward();
+  console.log(`${actor}'s balance in contract =>`, Number(ethers.utils.formatEther(await GaugeV2.balanceOf(address))));
+  console.log(
+    chalk.green(
+      `${actor}'s pickle balance after getting reward =>`,
+      Number(ethers.utils.formatEther(await pickle.balanceOf(address)))
+    )
+  );
+};
+
+describe("Liquidity Staking tests", () => {
+  before("Setting up gaugeV2", async () => {
+    const signer = ethers.provider.getSigner();
+    pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    dillHolder = ethers.provider.getSigner(dillHolderAddr);
+    [Luffy, Zoro, Sanji, Nami] = await ethers.getSigners();
+
+    // console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: dillHolderAddr,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("-- Sending gas cost to dillHolder addr --");
+    await signer.sendTransaction({
+      to: pickleHolder,
+      value: ethers.BigNumber.from("1000000000000000000"),
+      data: undefined,
+    });
+    console.log("------------------------ sent ------------------------");
+    console.log("pickleholder's ETH balance", await ethers.provider.getBalance(pickleHolder));
+    /** unlock accounts */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolderAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [pickleHolder],
+    });
+
+    pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    console.log("-- Deploying Gaugev2 contract --");
+    const gaugeV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeV2", pickleHolderSigner);
+    const tokenSymbols = ["PICKLE"];
+    const rewardTokens = [pickleAddr];
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, pickleHolder, tokenSymbols, rewardTokens);
+
+    await GaugeV2.deployed();
+
+    thisContractAddr = GaugeV2.address;
+    console.log("GaugeV2 deployed to:", thisContractAddr);
+    //GaugeContract by actors
+    GaugeV2ByLuffy = GaugeV2.connect(Luffy);
+    GaugeV2ByZoro = GaugeV2.connect(Zoro);
+    GaugeV2BySanji = GaugeV2.connect(Sanji);
+    GaugeV2ByNami = GaugeV2.connect(Nami);
+    GaugeV2BydillHolder = GaugeV2.connect(dillHolder);
+    pickleFromHolder = pickle.connect(pickleHolderSigner);
+    // console.log("PickleHolder's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(pickleHolder))));
+    console.log("------------------------ Depositing pickle ------------------------");
+    await pickleFromHolder.transfer(dillHolderAddr, tenPickles);
+    await pickleFromHolder.transfer(Luffy.address, ethers.utils.parseEther("20"));
+    await pickleFromHolder.transfer(Zoro.address, tenPickles);
+    await pickleFromHolder.transfer(Sanji.address, tenPickles);
+    await pickleFromHolder.transfer(Nami.address, tenPickles);
+    console.log("------------------------       Done        ------------------------");
+    console.log("===================================================================================================");
+    console.log(
+      "dillHolder's pickle balance ",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolderAddr)))
+    );
+    console.log("Luffy's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Zoro's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Zoro.address))));
+    console.log("Sanji's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address))));
+    console.log("Nami's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address))));
+    console.log("===================================================================================================");
+  });
+
+  it("Should test deposit and reward claim by multiple users ", async () => {
+    // Approvals for deposit
+    await pickle.connect(Luffy).approve(thisContractAddr, ethers.utils.parseEther("20"));
+    await pickle.connect(Zoro).approve(thisContractAddr, tenPickles);
+    await pickle.connect(Sanji).approve(thisContractAddr, tenPickles);
+    await pickle.connect(Nami).approve(thisContractAddr, tenPickles);
+    await pickle.connect(dillHolder).approve(thisContractAddr, ethers.utils.parseEther("20"));
+
+    // DepositAndLock(start time) for 1 year on the day contract is deployed
+    await GaugeV2ByLuffy.depositAndLock(tenPickles, 365 * 86400, false); // will claim just after every notify Reward
+    console.log(
+      chalk.green(
+        "Luffy's pickle balance after deposit and lock(10 pickles) =>",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+      )
+    );
+
+    await notifyRewardAmountMethod(); // 7 days
+    await notifyRewardAmountMethod(); // 14 days
+    await notifyRewardAmountMethod(); // 21 days
+    await notifyRewardAmountMethod(); // 28 days
+    advanceNDays(2); // 30 days
+    // 5 days to go to notify reward
+
+    // Deposit only (start time + 30 days)
+    await GaugeV2ByZoro.deposit(tenPickles);
+    console.log(
+      chalk.green(
+        "Zoro's pickle balance after deposit(10 pickles) only",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(Zoro.address)))
+      )
+    );
+
+    await notifyRewardAmountMethod(5); // 35 days
+
+    // DepositAndLock (start time + 35 days) for 180 days
+    await GaugeV2ByNami.depositAndLock(tenPickles, 180 * 86400, false);
+    console.log(
+      chalk.green(
+        "Nami's pickle balance after deposit and lock(10 pickles) =>",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address)))
+      )
+    );
+
+    // advanceNDays(30);
+    await notifyRewardAmountMethod(); // 42 days
+    await notifyRewardAmountMethod(); // 49 days
+    await notifyRewardAmountMethod(); // 56 days
+    await notifyRewardAmountMethod(); // 63 days
+
+    advanceNDays(2); // 65 days
+    // 5 days to go to notify reward
+
+    await getAndPrintReward("Nami", GaugeV2ByNami, Nami.address); // get reward by Nami before expiry
+
+    // DepositAndLock with dill balance(start time + 65 days) for 300 days
+    await GaugeV2BydillHolder.depositAndLock(tenPickles, 300 * 86400, false);
+    console.log(
+      chalk.green(
+        "DillHolder's pickle balance after deposit and lock(10 pickles) =>",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(dillHolderAddr)))
+      )
+    );
+
+    await notifyRewardAmountMethod(5); // 70 days
+
+    advanceNDays(5); // 75 days
+    // 2 days more to notify reward
+
+    //  DepositAndLock again by existing depositor (start time + 75 days) for 180 days // 2nd deposit
+    await GaugeV2ByLuffy.depositAndLock(tenPickles, 180 * 86400, false);
+    console.log(
+      chalk.green(
+        "Luffy's pickle balance after deposit and lock(10 pickles) =>",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+      )
+    );
+
+    //  DepositAndLock  (start time + 75 days) for 30 days
+    await GaugeV2BySanji.depositAndLock(tenPickles, 30 * 86400, false);
+    console.log(
+      chalk.green(
+        "Sanji's pickle balance after deposit and lock(10 pickles) =>",
+        Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
+      )
+    );
+
+    await notifyRewardAmountMethod(2); // 77 days
+    await notifyRewardAmountMethod(); // 84 days
+
+    // Advancing 19 weeks (217 days from start time) so that Nami's stake expires
+    for (let i = 0; i < 19; i++) {
+      await notifyRewardAmountMethod(false); // 217 days
+    }
+    await getAndPrintReward("Nami", GaugeV2ByNami, Nami.address); // Nami claims reward after stake expiry
+
+    await getAndPrintReward("Zoro", GaugeV2ByZoro, Zoro.address);
+
+    // Advancing 21 weeks (1 year from start time)
+    for (let i = 0; i < 21; i++) {
+      await notifyRewardAmountMethod(false); // 364 days
+    }
+    advanceNDays(2); // 366 days
+
+    // claim reward by Luffy after(1 day) stake lock expired where luffy was claiming his reward regularly
+    await getAndPrintReward("Luffy", GaugeV2ByLuffy, Luffy.address);
+
+    // claim reward by dillHolder much after stake lock expired where dillHolder never claimed his reward before
+    await getAndPrintReward("dillHolder", GaugeV2BydillHolder, dillHolderAddr);
+  });
+});
diff --git a/src/tests/dill/07_virtualGaugeV2.test.js b/src/tests/dill/07_virtualGaugeV2.test.js
new file mode 100644
index 000000000..df6890cfc
--- /dev/null
+++ b/src/tests/dill/07_virtualGaugeV2.test.js
@@ -0,0 +1,395 @@
+const {advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers} = require("hardhat");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const userAddr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+const zeroAddr = "0x0000000000000000000000000000000000000000";
+
+let userSigner,
+  Jar,
+  VirtualGaugeV2,
+  thisContractAddr,
+  pickle,
+  pickleHolderSigner,
+  governanceSigner,
+  dillHolderSigner,
+  Luffy,
+  Zoro,
+  Sanji,
+  Nami;
+
+const fivePickle = ethers.utils.parseEther("5");
+
+const printStakes = async (address) => {
+  let stakes = await Jar.getLockedStakesOf(address);
+  console.log("********************* Locked stakes ********************************************");
+  stakes.forEach((stake, index) => {
+    console.log(
+      "Liquidity in stake with index",
+      index,
+      ethers.utils.formatEther(stake.liquidity),
+      "ending timestamp",
+      stake.ending_timestamp,
+      "are",
+      stake.isPermanentlyLocked ? "locked" : "unlocked"
+    );
+  });
+  console.log("*******************************************************************************");
+};
+
+describe("Liquidity Staking tests", () => {
+  before("Setting up gaugeV2", async () => {
+    const signer = ethers.provider.getSigner();
+    pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    userSigner = ethers.provider.getSigner(userAddr);
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
+    [Luffy, Zoro, Sanji, Nami] = await ethers.getSigners();
+
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("-- Sending gas cost to dillHolder addr --");
+    await signer.sendTransaction({
+      to: dillHolder,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("------------------------ sent ------------------------");
+
+    /** unlock accounts */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [pickleHolder],
+    });
+
+    pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    console.log("-- Deploying jar contract --");
+    const jar = await ethers.getContractFactory("/src/dill/JarTemp.sol:JarTemp", pickleHolderSigner);
+    Jar = await jar.deploy();
+    await Jar.deployed();
+    console.log("Jar deployed at", Jar.address);
+
+    console.log("-- Deploying VirtualGaugeV2 contract --");
+    const virtualGaugeV2 = await ethers.getContractFactory(
+      "/src/dill/gauge-proxy-v2.sol:VirtualGaugeV2",
+      pickleHolderSigner
+    );
+    await expect(
+      virtualGaugeV2.deploy(zeroAddr, governanceAddr, pickleHolder, ["PICKLE"], [pickleAddr])
+    ).to.be.revertedWith("cannot set zero address");
+    VirtualGaugeV2 = await virtualGaugeV2.deploy(Jar.address, governanceAddr, pickleHolder, ["PICKLE"], [pickleAddr]);
+    await VirtualGaugeV2.deployed();
+    thisContractAddr = VirtualGaugeV2.address;
+    console.log("VirtualGaugeV2 deployed to:", thisContractAddr);
+
+    const pickleFromHolder = pickle.connect(pickleHolderSigner);
+
+    dillHolderSigner = ethers.provider.getSigner(dillHolder);
+
+    console.log("------------------------ Depositing pickle ------------------------");
+    await pickleFromHolder.transfer(dillHolder, ethers.utils.parseEther("100"));
+    await pickleFromHolder.transfer(userAddr, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Luffy.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Zoro.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Sanji.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Nami.address, ethers.utils.parseEther("10"));
+    console.log("------------------------       Done        ------------------------");
+  });
+  it("Should test staking successFully", async () => {
+    // approve => jar by => Luffy
+    console.log("Luffy's pickle balance => ", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    // await pickle.connect(Luffy).approve(Jar.address, fivePickle);
+
+    console.log(
+      "Pickle Balance of Luffy before depositing =>",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address)))
+    );
+
+    //Approve pickle for deposit
+    await pickle.connect(Luffy).approve(Jar.address, fivePickle);
+
+    await expect(Jar.depositForByJar(fivePickle, Luffy.address)).to.be.revertedWith("set jar first");
+
+    // Set Jar
+    await Jar.setVirtualGauge(VirtualGaugeV2.address);
+    const jarAd = await Jar.getVirtualGauge();
+    console.log("Virtual Gauge =>", jarAd);
+
+    // Deposit pickle
+    console.log("-- Depositing 5 pickle for Luffy --");
+    await Jar.depositForByJar(fivePickle, Luffy.address);
+    console.log("Jar Balance of Luffy", Number(ethers.utils.formatEther(await Jar.getBalanceOf(Luffy.address))));
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Pickle Balance of Jar =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Jar.address))));
+
+    //Approve pickle for deposit and lock
+    await pickle.connect(Luffy).approve(Jar.address, fivePickle);
+
+    // Deposit and lock
+    console.log("-- Deposit and lock 5 pickle for Luffy --");
+
+    await expect(
+      Jar.depositForAndLockByJar(0, Luffy.address, 86400 * 30, false, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Cannot stake 0");
+
+    await Jar.depositForAndLockByJar(fivePickle, Luffy.address, 86400 * 30, false, {
+      gasLimit: 9000000,
+    });
+    //Approve pickle for deposit and lock
+    await pickle.connect(Sanji).approve(Jar.address, fivePickle);
+
+    // Deposit and lock
+    console.log("-- Deposit and lock 5 pickle for Sanji --");
+    await Jar.depositForAndLockByJar(fivePickle, Sanji.address, 86400 * 300, false, {
+      gasLimit: 9000000,
+    });
+
+    //Approve pickle for deposit and lock
+    await pickle.connect(Zoro).approve(Jar.address, fivePickle);
+
+    // Deposit and lock
+    console.log("-- Deposit and lock 5 pickle for Sanji --");
+    await Jar.depositForAndLockByJar(fivePickle, Zoro.address, 86400 * 300, false, {
+      gasLimit: 9000000,
+    });
+    console.log("Jar Balance of Luffy", Number(ethers.utils.formatEther(await Jar.getBalanceOf(Luffy.address))));
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Pickle Balance of Jar =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Jar.address))));
+
+    await printStakes(Luffy.address);
+
+    advanceSevenDays();
+
+    // withdraw
+    console.log("-- Withdrawing Luffy's stake");
+
+    await expect(Jar.withdrawByJar(Luffy.address, 10)).to.be.revertedWith("Stake not found");
+
+    await Jar.withdrawByJar(Luffy.address, 0);
+    console.log("Jar Balance of Luffy", Number(ethers.utils.formatEther(await Jar.getBalanceOf(Luffy.address))));
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Pickle Balance of Jar =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Jar.address))));
+    await printStakes(Luffy.address);
+
+    // notify reward
+    const bal = await pickle.balanceOf(Jar.address);
+    await pickle.connect(pickleHolderSigner).approve(VirtualGaugeV2.address, bal);
+    // await VirtualGaugeV2.notifyRewardAmount([bal]);
+    await expect(
+      VirtualGaugeV2.connect(Luffy).notifyRewardAmount([bal], {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Caller is not RewardsDistribution contract");
+
+    console.log("-- Executing NotifyReward --");
+    await VirtualGaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal], {
+      gasLimit: 9000000,
+    });
+    //get Reward
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("Total Supply =>", await VirtualGaugeV2.totalSupply());
+    console.log("--Executing get reward --");
+    await Jar.getRewardByJar(Luffy.address, {
+      gasLimit: 90000000,
+    });
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+
+    console.log("-- Unlocking Stakes for Luffy --");
+    // console.log()
+    await VirtualGaugeV2.connect(governanceSigner).unlockStakeForAccount(Luffy.address);
+
+    await printStakes(Luffy.address);
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    console.log("-- Withdrawing --");
+    await Jar.withdrawAllByJar(Luffy.address);
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Luffy.address))));
+    // print Luffy's Stakes
+    await printStakes(Luffy.address);
+
+    console.log("Pickle Balance of Luffy =>", Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address))));
+
+    // Test multipliers for 1 year and 300 year should be equal
+    const multiplierForOneYear = await VirtualGaugeV2.lockMultiplier(86400 * 365);
+    const multiplierForTwentyYear = await VirtualGaugeV2.lockMultiplier(86400 * 365 * 20);
+    expect(multiplierForOneYear).to.eq(multiplierForTwentyYear);
+
+    console.log(" -- Emergency unlock all stakes -- ");
+    await VirtualGaugeV2.connect(governanceSigner).unlockStakes();
+
+    console.log(" -- Zoro's stake -- ");
+    await printStakes(Zoro.address);
+
+    console.log("-- Exiting Zoro -- ");
+    await Jar.exitByJar(Zoro.address);
+
+    console.log(" -- Zoro's stake after exit -- ");
+    await printStakes(Zoro.address);
+
+    await expect(
+      VirtualGaugeV2.connect(governanceSigner).setMaxRewardsDuration(86400 * 400, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Reward period incomplete");
+    await advanceSevenDays();
+    await advanceSevenDays();
+
+    // test various setters
+    console.log(" -- Testing MaxDuration setters -- ");
+    await expect(VirtualGaugeV2.setMaxRewardsDuration(86400, {gasLimit: 9000000})).to.be.revertedWith(
+      "Operation allowed by only governance"
+    );
+    await expect(
+      VirtualGaugeV2.connect(governanceSigner).setMaxRewardsDuration(8640, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Rewards duration too short");
+    const newMaxTime = 86400 * 400;
+    await VirtualGaugeV2.connect(governanceSigner).setMaxRewardsDuration(newMaxTime, {
+      gasLimit: 9000000,
+    });
+    const maxTime = await VirtualGaugeV2.lockTimeForMaxMultiplier();
+    expect(newMaxTime).to.be.eq(maxTime);
+
+    console.log(" -- Testing multiplier setters -- ");
+    await expect(VirtualGaugeV2.setMultipliers(1, {gasLimit: 9000000})).to.be.revertedWith(
+      "Operation allowed by only governance"
+    );
+    await expect(
+      VirtualGaugeV2.connect(governanceSigner).setMultipliers(10 ** 14, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Multiplier must be greater than or equal to 1e18");
+    console.log("Multiplier =>", await VirtualGaugeV2.lockMaxMultiplier());
+    const newMultilier = ethers.utils.parseEther("1"); //new BigNumber(10 ** 19).toFixed();
+    await VirtualGaugeV2.connect(governanceSigner).setMultipliers(newMultilier, {
+      gasLimit: 9000000,
+    });
+    const maxMultiplier = await VirtualGaugeV2.lockMaxMultiplier();
+    expect(maxMultiplier).to.be.eq(newMultilier);
+
+    await expect(VirtualGaugeV2.setJar(Jar.address)).to.be.revertedWith("Operation allowed by only governance");
+    await expect(VirtualGaugeV2.connect(governanceSigner).setJar(zeroAddr)).to.be.revertedWith("cannot set to zero");
+
+    await expect(VirtualGaugeV2.connect(governanceSigner).setJar(Jar.address)).to.be.revertedWith("Jar is already set");
+
+    //maxMultiplier and duration
+    const multiplierFor1year = await VirtualGaugeV2.lockMultiplier(86400 * 365);
+    const multiplierFor2year = await VirtualGaugeV2.lockMultiplier(86400 * 365 * 2);
+    expect(multiplierFor1year).to.equal(multiplierFor2year);
+
+    const rewardForDuration = await VirtualGaugeV2.getRewardForDuration();
+    console.log("rewardForDuration =>", rewardForDuration);
+  });
+  it("Test partial withdrawal", async () => {
+    await pickle.connect(dillHolderSigner).approve(Jar.address, 0);
+
+    const DillHolderPickleBalance = await pickle.connect(dillHolderSigner).balanceOf(dillHolder);
+    await pickle.connect(dillHolderSigner).approve(Jar.address, DillHolderPickleBalance);
+    await expect(
+      Jar.depositForAndLockByJar(fivePickle, dillHolder, 86, false, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Minimum stake time not met");
+
+    await expect(
+      Jar.depositForAndLockByJar(fivePickle, dillHolder, 86400 * 401, false, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Trying to lock for too long");
+
+    await expect(
+      Jar.depositForAndLockByJar(fivePickle, dillHolder, 86, false, {
+        gasLimit: 9000000,
+      })
+    ).to.be.revertedWith("Minimum stake time not met");
+
+    console.log(" -- deposit and lock 5 pickle for 3 days -- ");
+    await Jar.depositForAndLockByJar(fivePickle, dillHolder, 86400 * 3, false, {
+      gasLimit: 9000000,
+    });
+    console.log(" -- deposit and lock 5 pickle for 365 days -- ");
+    await Jar.depositForAndLockByJar(fivePickle, dillHolder, 86400 * 365, false, {
+      gasLimit: 9000000,
+    });
+
+    console.log(" -- deposit and lock 5 pickle 1 day -- ");
+    await Jar.depositForAndLockByJar(fivePickle, dillHolder, 86400, false, {
+      gasLimit: 9000000,
+    });
+
+    console.log(" -- deposit and lock 5 pickle permanently -- ");
+    await Jar.depositForAndLockByJar(fivePickle, dillHolder, 86400, true, {
+      gasLimit: 9000000,
+    });
+    // console.log(" -- deposit all remaining pickle -- ");
+    // await Jar.depositAll({ gasLimit: 9000000 });
+
+    await printStakes(dillHolder);
+    advanceSevenDays();
+
+    await expect(Jar.partialWithdrawalByJar(dillHolder, ethers.utils.parseEther("5000"))).to.be.revertedWith(
+      "Withdraw amount exceeds balance"
+    );
+
+    // Withdraw 5 pickle (= liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 5 pickle -- ");
+    await Jar.partialWithdrawalByJar(dillHolder, fivePickle); // working fine
+
+    await printStakes(dillHolder);
+
+    // Withdraw 2 pickle (< liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 2 pickle -- ");
+    await Jar.partialWithdrawalByJar(dillHolder, ethers.utils.parseEther("2")); // working fine
+
+    await printStakes(dillHolder);
+
+    // Withdraw 5 pickle (> liquidity in first unlocked stake)
+    console.log(" -- Partially withdrawing 5 pickle -- ");
+    await Jar.partialWithdrawalByJar(dillHolder, fivePickle);
+
+    await printStakes(dillHolder);
+
+    // await expect(
+    //   Jar.withdrawByJar(dillHolder, 3)
+    // ).to.be.revertedWith("Stake is still locked!");
+
+    //set jar to other address
+    await VirtualGaugeV2.connect(governanceSigner).setAuthoriseAddress(governanceAddr, true);
+    await expect(VirtualGaugeV2.connect(governanceSigner).setAuthoriseAddress(governanceAddr, true)).to.be.revertedWith(
+      "address is already set to given value"
+    );
+
+    console.log("-- Exiting dillHolder");
+    await Jar.exitByJar(dillHolder);
+
+    await printStakes(dillHolder);
+  });
+});
diff --git a/src/tests/dill/08_virtualGaugeV2_gaugeProxy_upgrade.test.js b/src/tests/dill/08_virtualGaugeV2_gaugeProxy_upgrade.test.js
new file mode 100644
index 000000000..748491034
--- /dev/null
+++ b/src/tests/dill/08_virtualGaugeV2_gaugeProxy_upgrade.test.js
@@ -0,0 +1,235 @@
+const {advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const userAddr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const zeroAddr = "0x0000000000000000000000000000000000000000";
+
+let userSigner,
+  Jar,
+  VirtualGaugeV2,
+  GaugeProxyV2,
+  thisContractAddr,
+  pickle,
+  pickleHolderSigner,
+  governanceSigner,
+  Luffy,
+  Zoro,
+  Sanji,
+  Nami;
+
+describe("Liquidity Staking tests", () => {
+  before("Setting up gaugeV2", async () => {
+    pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    userSigner = ethers.provider.getSigner(userAddr);
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
+    [Luffy, Zoro, Sanji, Nami] = await ethers.getSigners();
+
+    console.log("-- Sending gas cost to governance addr --");
+    await Nami.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("-- Sending gas cost to dillHolder addr --");
+    await Nami.sendTransaction({
+      to: dillHolder,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
+
+    console.log("------------------------ sent ------------------------");
+
+    /** unlock accounts */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [pickleHolder],
+    });
+
+    pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+    console.log("-- Deploying jar contract --");
+    const jar = await ethers.getContractFactory("/src/dill/JarTemp.sol:JarTemp", pickleHolderSigner);
+    Jar = await jar.deploy();
+    await Jar.deployed();
+    console.log("Jar deployed at", Jar.address);
+
+    console.log("-- Deploying VirtualGaugeV2 contract --");
+    const virtualGaugeV2 = await ethers.getContractFactory(
+      "/src/dill/gauge-proxy-v2.sol:VirtualGaugeV2",
+      pickleHolderSigner
+    );
+    VirtualGaugeV2 = await virtualGaugeV2.deploy(Jar.address, governanceAddr, pickleHolder, ["PICKLE"], [pickleAddr]);
+    await VirtualGaugeV2.deployed();
+    thisContractAddr = VirtualGaugeV2.address;
+    console.log("VirtualGaugeV2 deployed to:", thisContractAddr);
+
+    const pickleFromHolder = pickle.connect(pickleHolderSigner);
+
+    dillHolderSigner = ethers.provider.getSigner(dillHolder);
+
+    console.log("------------------------ Depositing pickle ------------------------");
+    await pickleFromHolder.transfer(dillHolder, ethers.utils.parseEther("100"));
+    await pickleFromHolder.transfer(userAddr, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Luffy.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Zoro.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Sanji.address, ethers.utils.parseEther("10"));
+    await pickleFromHolder.transfer(Nami.address, ethers.utils.parseEther("10"));
+    console.log("------------------------       Done        ------------------------");
+  });
+  // await hre.network.provider.send("hardhat_reset");
+  it("Should successfully test virtual Gauge and gaugeProxyV2 together", async () => {
+    //deploy gaugeproxy
+    userSigner = ethers.provider.getSigner(userAddr);
+    const masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+
+    // getting timestamp
+    const blockNumBefore = await ethers.provider.getBlockNumber();
+    const blockBefore = await ethers.provider.getBlock(blockNumBefore);
+    const timestampBefore = blockBefore.timestamp;
+    // console.log(timestampBefore);
+
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [timestampBefore], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+
+    let populatedTx = await masterChef.populateTransaction.add(5000000, mDILLAddr, false);
+    await governanceSigner.sendTransaction(populatedTx);
+
+    console.log("-- Deploying VirtualGaugeMiddleware contract --");
+    const virtualGaugeMiddleware = await ethers.getContractFactory(
+      "/src/dill/gauge-middleware.sol:VirtualGaugeMiddleware",
+      governanceSigner
+    );
+
+    /** Deploy gaugeMiddleware successfully */
+    await expect(
+      upgrades.deployProxy(virtualGaugeMiddleware, [governanceAddr, governanceAddr], {
+        initializer: "initialize",
+      })
+    ).to.be.revertedWith("_governance address and _gaugeProxy cannot be same");
+
+    await expect(
+      upgrades.deployProxy(virtualGaugeMiddleware, [zeroAddr, governanceAddr], {
+        initializer: "initialize",
+      })
+    ).to.be.revertedWith("_gaugeProxy address cannot be set to zero");
+
+    const VirtualGaugeMiddleware = await upgrades.deployProxy(
+      virtualGaugeMiddleware,
+      [masterChefAddr, governanceAddr],
+      {
+        initializer: "initialize",
+      }
+    );
+    await VirtualGaugeMiddleware.deployed();
+    console.log("VirtualGaugeMiddleware deployed at", VirtualGaugeMiddleware.address);
+
+    /** add gaugeMiddleware*/
+    await expect(VirtualGaugeMiddleware.connect(userSigner).changeGaugeProxy(GaugeProxyV2.address)).to.be.revertedWith(
+      "can only be called by governance"
+    );
+
+    console.log("-- Changing proxy --");
+    await VirtualGaugeMiddleware.connect(governanceSigner).changeGaugeProxy(GaugeProxyV2.address);
+
+    await expect(GaugeProxyV2.addVirtualGaugeMiddleware(zeroAddr)).to.be.revertedWith(
+      "virtualGaugeMiddleware cannot set to zero"
+    );
+
+    console.log("-- Adding Virtual Gauge middleWare --");
+    await GaugeProxyV2.addVirtualGaugeMiddleware(VirtualGaugeMiddleware.address);
+
+    await expect(
+      VirtualGaugeMiddleware.addVirtualGauge(pickleLP, Jar.address, ["PKL"], [pickleAddr])
+    ).to.be.revertedWith("can only be called by gaugeProxy");
+
+    await expect(GaugeProxyV2.addVirtualGauge(pickleLP, zeroAddr)).to.be.revertedWith("address of jar cannot be zero");
+
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addVirtualGauge(pickleLP, Jar.address);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addVirtualGauge(pyveCRVETH, Jar.address);
+
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
+
+    // vote
+    console.log("-- VOTING --");
+    populatedTx = await GaugeProxyV2.connect(userSigner).populateTransaction.vote(
+      [pickleLP, pyveCRVETH],
+      [6000000, 4000000],
+      {
+        gasLimit: 9000000,
+      }
+    );
+    await userSigner.sendTransaction(populatedTx);
+
+    advanceSevenDays();
+  });
+  it("Should upgrade gaugeProxy successfully", async () => {
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+    console.log("Upgrading GaugeProxy...");
+    const upgradeGaugeProxy = await upgrades.upgradeProxy(
+      GaugeProxyV2.address, // address of proxy deployed
+      gaugeProxyV2
+    );
+    console.log("gaugeProxy upgraded");
+
+    console.log("check =>", await upgradeGaugeProxy.length());
+
+    console.log("-- Distributing --");
+    await GaugeProxyV2.distribute(0, 2, {
+      gasLimit: 9000000,
+    });
+
+    let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+    let pickleRewards = Number(await pickle.balanceOf(pickleGaugeAddr));
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
+
+    let yvecrvRewards = Number(await pickle.balanceOf(yvecrvGaugeAddr));
+    console.log("Rewards to pyveCRV gauge => ", yvecrvRewards.toString());
+  });
+});
diff --git a/src/tests/dill/gaugeProxyV2Test.js b/src/tests/dill/gaugeProxyV2Test.js
new file mode 100644
index 000000000..ab06c4747
--- /dev/null
+++ b/src/tests/dill/gaugeProxyV2Test.js
@@ -0,0 +1,185 @@
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+const {it} = require("mocha");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+
+async function advanceSevenDays() {
+  /** ************************************* increase time by 7 days ****************************************** */
+  console.log("-- Wait 7 days to accumulate");
+  await hre.network.provider.request({
+    method: "evm_increaseTime",
+    params: [3600 * 24 * 7],
+  });
+
+  /** ************************************* mine block ****************************************** */
+  console.log("-- Wait for 1 block to be mined --");
+  await hre.network.provider.request({
+    method: "evm_mine",
+  });
+}
+
+describe("vote & distribute", () => {
+  before("setting up gaugeProxyV2", async () => {
+    /**
+     *  sending gas cost to gov
+     *
+     * */
+    const signer = ethers.provider.getSigner();
+    console.log((await signer.getBalance()).toString());
+    console.log("-- Sending gas cost to governance addr --");
+    await signer.sendTransaction({
+      to: governanceAddr,
+      value: ethers.BigNumber.from("10000000000000000000"), // 1000 ETH
+      data: undefined,
+    });
+
+    /** unlock governance account */
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [governanceAddr],
+    });
+
+    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    const userSigner = ethers.provider.getSigner(userAddr);
+    const masterChef = await ethers.getContractAt(
+      "src/yield-farming/masterchef.sol:MasterChef",
+      masterChefAddr,
+      governanceSigner
+    );
+    masterChef.connect(governanceSigner);
+
+    /** Deploy gaugeProxyV2 */
+    console.log("-- Deploying GaugeProxy v2 contract --");
+    const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
+    console.log("Deploying GaugeProxyV2...");
+    const GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Date.now()], {
+      initializer: "initialize",
+    });
+    await GaugeProxyV2.deployed();
+    console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+
+    const mDILLAddr = await GaugeProxyV2.TOKEN();
+    console.log("-- Adding mDILL to MasterChef --");
+    let populatedTx;
+    populatedTx = await masterChef.populateTransaction.add(
+      5000000,
+      mDILLAddr,
+      false
+      // { gasLimit: 9000000 }
+    );
+    await governanceSigner.sendTransaction(populatedTx);
+
+    console.log("-- Adding PICKLE LP Gauge --");
+    await GaugeProxyV2.addGauge(pickleLP);
+
+    console.log("-- Adding pyveCRVETH Gauge --");
+    await GaugeProxyV2.addGauge(pyveCRVETH);
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    it("should vote successfully (first voting)", async () => {
+      console.log("-- Voting on LP Gauge with 100% weight --");
+      const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+      populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+        gasLimit: 9000000,
+      });
+      await userSigner.sendTransaction(populatedTx);
+
+      const pidDill = (await masterChef.poolLength()) - 1;
+      await GaugeProxyV2.setPID(pidDill);
+      await GaugeProxyV2.deposit();
+
+      await hre.network.provider.request({
+        method: "evm_mine",
+      });
+    });
+ 
+    it("Distribute PICKLE to gauges should fail as voiting still in progress", async () => {
+      await GaugeProxyV2.distribute(0, 2);
+      const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+      const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+      const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+      let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+      console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+      let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+      console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+    });
+    it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
+      await advanceSevenDays();
+      /**
+       * FIRST CHUNK DISTRIBUTION
+       */
+      console.log("currentId", (await GaugeProxyV2.currentId()).toString());
+      console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+      await GaugeProxyV2.distribute(0, 1);
+      let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+      let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+      const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+      let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+      console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+      let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+      console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+
+      /**
+       * SECOND CHUNK DISTRIBUTION
+       */
+      console.log("currentId", (await GaugeProxyV2.currentId()).toString());
+      console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+      await GaugeProxyV2.distribute(1, 2);
+      pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+      yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+
+      pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+      console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+      yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+      console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+    });
+
+    it("should distribute similar rewards for the periods users not voted for", async () => {
+      console.log("advancing 3 weeks");
+      await advanceSevenDays();
+      await advanceSevenDays();
+      await advanceSevenDays();
+
+      const cid = await GaugeProxyV2.currentId();
+      const did = await GaugeProxyV2.distributionId();
+
+      console.log("currentId", cid.toString());
+      console.log("distributionId", did.toString());
+
+      for (let i = did; i < cid; i++) {
+        console.log("distributing for id ", i);
+        await GaugeProxyV2.distribute(0, 2);
+        let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+        let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+        const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+
+        let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+        console.log("rewards to Pickle gauge", pickleRewards.toString());
+
+        let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+        console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+      }
+    });
+    it("should set delegate successfully and vote for user", async () => {
+      await GaugeProxyV2.setVotingDelegate(governanceAddr, 1, false);
+      await GaugeProxyV2.voteFor(userAddr,[pickleLP, pyveCRVETH], [6000000, 4000000]);
+    });
+  });
+});
diff --git a/src/tests/dill/testHelper.js b/src/tests/dill/testHelper.js
new file mode 100644
index 000000000..4ac5262ed
--- /dev/null
+++ b/src/tests/dill/testHelper.js
@@ -0,0 +1,55 @@
+const hre = require("hardhat");
+const {ethers} = require("hardhat");
+
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+
+async function advanceNDays(days) {
+  /**************** increase time by 7 days ******************* */
+  console.log(`-- Advancing ${days} dyas --`);
+  await hre.network.provider.request({
+    method: "evm_increaseTime",
+    params: [3600 * 24 * days],
+  });
+
+  /** ******************* mine block ************************* */
+  await hre.network.provider.request({
+    method: "evm_mine",
+  });
+}
+
+async function advanceSevenDays() {
+  advanceNDays(7);
+}
+
+/**
+ *
+ * @param {contract} GaugeProxyV2
+ * @param {array} lpAddr
+ * @param {number} start
+ * @param {number} end
+ * @returns array
+ */
+async function distribute(GaugeProxyV2, lpAddr, start, end) {
+  // await advanceSevenDays();
+  console.log("This distribution is as per user's vote");
+  console.log("Current Id => ", Number(await GaugeProxyV2.getCurrentPeriodId()));
+  console.log("Distribution Id => ", Number(await GaugeProxyV2.distributionId()));
+  await GaugeProxyV2.distribute(start, end);
+
+  const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+  let rewards = [];
+
+  lpAddr.forEach(async (lp) => {
+    const gaugeAddr = await GaugeProxyV2.getGauge(lp);
+    const rewardsGauge = await pickle.balanceOf(gaugeAddr);
+    rewards.push(Number(rewardsGauge));
+  });
+
+  return rewards;
+}
+
+module.exports = {
+  advanceNDays,
+  advanceSevenDays,
+  distribute,
+};