From 52272ecb867d50393b805fa43384d63904d61115 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 23 Mar 2022 23:29:32 +0530
Subject: [PATCH 01/55] WIP: gauge-proxy-v2

---
 src/dill/gauge-proxy-v2.sol                | 931 +++++++++++++++++++++
 src/dill/scripts/deploy_gauge_proxy_V2.js  |  18 +
 src/dill/scripts/upgrade_gauge_proxy_v2.js |  13 +
 3 files changed, 962 insertions(+)
 create mode 100644 src/dill/gauge-proxy-v2.sol
 create mode 100644 src/dill/scripts/deploy_gauge_proxy_V2.js
 create mode 100644 src/dill/scripts/upgrade_gauge_proxy_v2.js

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
new file mode 100644
index 000000000..8ebd05a35
--- /dev/null
+++ b/src/dill/gauge-proxy-v2.sol
@@ -0,0 +1,931 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.6.7; //^0.7.5;
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "add: +");
+
+        return c;
+    }
+
+    function add(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, errorMessage);
+
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "sub: -");
+    }
+
+    function sub(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+        // benefit is lost if 'b' is also tested.
+        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
+        if (a == 0) {
+            return 0;
+        }
+
+        uint256 c = a * b;
+        require(c / a == b, "mul: *");
+
+        return c;
+    }
+
+    function mul(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+
+        uint256 c = a * b;
+        require(c / a == b, errorMessage);
+
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "div: /");
+    }
+
+    function div(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+
+        return c;
+    }
+}
+
+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));
+    }
+
+    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);
+}
+
+library SafeERC20 {
+    using SafeMath for uint256;
+    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).add(
+            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).sub(
+            value,
+            "SafeERC20: decreased allowance below zero"
+        );
+        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() public {
+        _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 Gauge is ReentrancyGuard {
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    IERC20 public constant PICKLE =
+        IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
+    IERC20 public constant DILL =
+        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
+    address public constant TREASURY =
+        address(0x066419EaEf5DE53cc5da0d8702b990c5bc7D1AB3);
+
+    IERC20 public immutable TOKEN;
+    address public immutable DISTRIBUTION;
+    uint256 public constant DURATION = 7 days;
+
+    uint256 public periodFinish = 0;
+    uint256 public rewardRate = 0;
+    uint256 public lastUpdateTime;
+    uint256 public rewardPerTokenStored;
+
+    modifier onlyDistribution() {
+        require(
+            msg.sender == DISTRIBUTION,
+            "Caller is not RewardsDistribution contract"
+        );
+        _;
+    }
+
+    mapping(address => uint256) public userRewardPerTokenPaid;
+    mapping(address => uint256) public rewards;
+
+    uint256 private _totalSupply;
+    uint256 public derivedSupply;
+    mapping(address => uint256) private _balances;
+    mapping(address => uint256) public derivedBalances;
+    mapping(address => uint256) private _base;
+
+    constructor(address _token) public {
+        TOKEN = IERC20(_token);
+        DISTRIBUTION = msg.sender;
+    }
+
+    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) {
+        if (_totalSupply == 0) {
+            return rewardPerTokenStored;
+        }
+        return
+            rewardPerTokenStored.add(
+                lastTimeRewardApplicable()
+                    .sub(lastUpdateTime)
+                    .mul(rewardRate)
+                    .mul(1e18)
+                    .div(derivedSupply)
+            );
+    }
+
+    function derivedBalance(address account) public view returns (uint256) {
+        uint256 _balance = _balances[account];
+        uint256 _derived = _balance.mul(40).div(100);
+        uint256 _adjusted = (
+            _totalSupply.mul(DILL.balanceOf(account)).div(DILL.totalSupply())
+        ).mul(60).div(100);
+        return Math.min(_derived.add(_adjusted), _balance);
+    }
+
+    function kick(address account) public {
+        uint256 _derivedBalance = derivedBalances[account];
+        derivedSupply = derivedSupply.sub(_derivedBalance);
+        _derivedBalance = derivedBalance(account);
+        derivedBalances[account] = _derivedBalance;
+        derivedSupply = derivedSupply.add(_derivedBalance);
+    }
+
+    function earned(address account) public view returns (uint256) {
+        return
+            derivedBalances[account]
+                .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
+                .div(1e18)
+                .add(rewards[account]);
+    }
+
+    function getRewardForDuration() external view returns (uint256) {
+        return rewardRate.mul(DURATION);
+    }
+
+    function depositAll() external {
+        _deposit(TOKEN.balanceOf(msg.sender), msg.sender);
+    }
+
+    function deposit(uint256 amount) external {
+        _deposit(amount, msg.sender);
+    }
+
+    function depositFor(uint256 amount, address account) external {
+        _deposit(amount, account);
+    }
+
+    function _deposit(uint256 amount, address account)
+        internal
+        nonReentrant
+        updateReward(account)
+    {
+        require(amount > 0, "Cannot stake 0");
+        _totalSupply = _totalSupply.add(amount);
+        _balances[account] = _balances[account].add(amount);
+        emit Staked(account, amount);
+        TOKEN.safeTransferFrom(account, address(this), amount);
+    }
+
+    function withdrawAll() external {
+        _withdraw(_balances[msg.sender]);
+    }
+
+    function withdraw(uint256 amount) external {
+        _withdraw(amount);
+    }
+
+    function _withdraw(uint256 amount)
+        internal
+        nonReentrant
+        updateReward(msg.sender)
+    {
+        require(amount > 0, "Cannot withdraw 0");
+        _totalSupply = _totalSupply.sub(amount);
+        _balances[msg.sender] = _balances[msg.sender].sub(amount);
+        TOKEN.safeTransfer(msg.sender, amount);
+        emit Withdrawn(msg.sender, amount);
+    }
+
+    function getReward() public nonReentrant updateReward(msg.sender) {
+        uint256 reward = rewards[msg.sender];
+        if (reward > 0) {
+            rewards[msg.sender] = 0;
+            PICKLE.safeTransfer(msg.sender, reward);
+            emit RewardPaid(msg.sender, reward);
+        }
+    }
+
+    function exit() external {
+        _withdraw(_balances[msg.sender]);
+        getReward();
+    }
+
+    function notifyRewardAmount(uint256 reward)
+        external
+        onlyDistribution
+        updateReward(address(0))
+    {
+        PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
+        if (block.timestamp >= periodFinish) {
+            rewardRate = reward.div(DURATION);
+        } else {
+            uint256 remaining = periodFinish.sub(block.timestamp);
+            uint256 leftover = remaining.mul(rewardRate);
+            rewardRate = reward.add(leftover).div(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 = PICKLE.balanceOf(address(this));
+        require(
+            rewardRate <= balance.div(DURATION),
+            "Provided reward too high"
+        );
+
+        lastUpdateTime = block.timestamp;
+        periodFinish = block.timestamp.add(DURATION);
+        emit RewardAdded(reward);
+    }
+
+    modifier updateReward(address account) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateTime = lastTimeRewardApplicable();
+        if (account != address(0)) {
+            rewards[account] = earned(account);
+            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+        }
+        _;
+        if (account != address(0)) {
+            kick(account);
+        }
+    }
+
+    event RewardAdded(uint256 reward);
+    event Staked(address indexed user, uint256 amount);
+    event Withdrawn(address indexed user, uint256 amount);
+    event RewardPaid(address indexed user, uint256 reward);
+}
+
+interface MasterChef {
+    function deposit(uint256, uint256) external;
+
+    function withdraw(uint256, uint256) external;
+
+    function userInfo(uint256, address)
+        external
+        view
+        returns (uint256, uint256);
+}
+
+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;
+    }
+}
+
+contract MasterDill {
+    using SafeMath for uint256;
+
+    /// @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() public {
+        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];
+
+        if (spender != src && spenderAllowance != uint256(-1)) {
+            uint256 newAllowance = spenderAllowance.sub(
+                amount,
+                "transferFrom: exceeds spender allowance"
+            );
+            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");
+
+        balances[src] = balances[src].sub(
+            amount,
+            "_transferTokens: exceeds balance"
+        );
+        balances[dst] = balances[dst].add(amount, "_transferTokens: overflows");
+        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 SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    MasterChef public constant MASTER =
+        MasterChef(0xbD17B1ce622d73bD438b9E658acA5996dc394b0d);
+    IERC20 public constant DILL =
+        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
+    IERC20 public constant PICKLE =
+        IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
+
+    IERC20 public immutable TOKEN = IERC20(address(new MasterDill()));
+
+    uint256 public pid;
+    uint256 public totalWeight;
+
+    address[] internal _tokens;
+    mapping(address => address) public gauges; // token => gauge
+    mapping(address => uint256) public weights; // token => weight
+    mapping(address => mapping(address => uint256)) public votes; // msg.sender => votes
+    mapping(address => address[]) public tokenVote; // msg.sender => token
+    mapping(address => uint256) public usedWeights; // msg.sender => total voting weight of user
+
+    function tokens() external view returns (address[] memory) {
+        return _tokens;
+    }
+
+    function getGauge(address _token) external view returns (address) {
+        return gauges[_token];
+    }
+
+    function initialize() public initializer {
+        // TOKEN = IERC20(address(new MasterDill()));
+        governance = msg.sender;
+    }
+
+    // Reset votes to 0
+    function reset() external {
+        _reset(msg.sender);
+    }
+
+    // Reset votes to 0
+    function _reset(address _owner) internal {
+        address[] storage _tokenVote = tokenVote[_owner];
+        uint256 _tokenVoteCnt = _tokenVote.length;
+
+        for (uint256 i = 0; i < _tokenVoteCnt; i++) {
+            address _token = _tokenVote[i];
+            uint256 _votes = votes[_owner][_token];
+
+            if (_votes > 0) {
+                totalWeight = totalWeight.sub(_votes);
+                weights[_token] = weights[_token].sub(_votes);
+
+                votes[_owner][_token] = 0;
+            }
+        }
+
+        delete tokenVote[_owner];
+    }
+
+    // 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;
+        uint256[] memory _weights = new uint256[](_tokenCnt);
+
+        uint256 _prevUsedWeight = usedWeights[_owner];
+        uint256 _weight = DILL.balanceOf(_owner);
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            uint256 _prevWeight = votes[_owner][_tokenVote[i]];
+            _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
+        }
+
+        _vote(_owner, _tokenVote, _weights);
+    }
+
+    function _vote(
+        address _owner,
+        address[] memory _tokenVote,
+        uint256[] memory _weights
+    ) internal {
+        // _weights[i] = percentage * 100
+        _reset(_owner);
+        uint256 _tokenCnt = _tokenVote.length;
+        uint256 _weight = DILL.balanceOf(_owner);
+        uint256 _totalVoteWeight = 0;
+        uint256 _usedWeight = 0;
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
+        }
+
+        for (uint256 i = 0; i < _tokenCnt; i++) {
+            address _token = _tokenVote[i];
+            address _gauge = gauges[_token];
+            uint256 _tokenWeight = _weights[i].mul(_weight).div(
+                _totalVoteWeight
+            );
+
+            if (_gauge != address(0x0)) {
+                _usedWeight = _usedWeight.add(_tokenWeight);
+                totalWeight = totalWeight.add(_tokenWeight);
+                weights[_token] = weights[_token].add(_tokenWeight);
+                tokenVote[_owner].push(_token);
+                votes[_owner][_token] = _tokenWeight;
+            }
+        }
+
+        usedWeights[_owner] = _usedWeight;
+    }
+
+    // Vote with DILL on a gauge
+    function vote(address[] calldata _tokenVote, uint256[] calldata _weights)
+        external
+    {
+        require(_tokenVote.length == _weights.length);
+        _vote(msg.sender, _tokenVote, _weights);
+    }
+
+    // Add new token gauge
+    function addGauge(address _token) external {
+        require(msg.sender == governance, "!gov");
+        require(gauges[_token] == address(0x0), "exists");
+        gauges[_token] = address(new Gauge(_token));
+        _tokens.push(_token);
+    }
+
+    // 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 {
+        collect();
+        require(_start < _end, "bad _start");
+        require(_end <= _tokens.length, "bad _end");
+        uint256 _balance = PICKLE.balanceOf(address(this));
+        if (_balance > 0 && totalWeight > 0) {
+            for (uint256 i = 0; i < _tokens.length; i++) {
+                address _token = _tokens[i];
+                address _gauge = gauges[_token];
+                uint256 _reward = _balance.mul(weights[_token]).div(
+                    totalWeight
+                );
+                if (_reward > 0) {
+                    PICKLE.safeApprove(_gauge, 0);
+                    PICKLE.safeApprove(_gauge, _reward);
+                    Gauge(_gauge).notifyRewardAmount(_reward);
+                }
+            }
+        }
+    }
+}
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..ccf52f120
--- /dev/null
+++ b/src/dill/scripts/deploy_gauge_proxy_V2.js
@@ -0,0 +1,18 @@
+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("Deploying GaugeProxyV2...");
+  const GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2);
+  await GaugeProxyV2.deployed();
+  console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
+}
+
+
+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..3e8f7e742
--- /dev/null
+++ b/src/dill/scripts/upgrade_gauge_proxy_v2.js
@@ -0,0 +1,13 @@
+const { ethers, upgrades } = require("hardhat");
+
+async function main() {
+  const GaugeProxyV2 = await ethers.getContractFactory("gaugeProxyV2");
+  console.log("Upgrading GaugeProxy...");
+  await upgrades.upgradeProxy(
+    "",
+    GaugeProxyV2
+  );
+  console.log("gaugeProxy upgraded");
+}
+
+main();

From 2047c4cbaf0b485325933231cfb8e0359ff3c0a2 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 30 Mar 2022 18:14:56 +0530
Subject: [PATCH 02/55] feat: add periodization to voting

---
 src/dill/gauge-proxy-v2.sol                | 51 +++++++++++++++++++---
 src/dill/scripts/deploy_gauge_proxy_V2.js  | 19 ++++++--
 src/dill/scripts/upgrade_gauge_proxy_v2.js | 20 +++++++--
 3 files changed, 75 insertions(+), 15 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 8ebd05a35..f4f7d8787 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -761,7 +761,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     IERC20 public constant PICKLE =
         IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
 
-    IERC20 public immutable TOKEN = IERC20(address(new MasterDill()));
+    IERC20 public TOKEN;
 
     uint256 public pid;
     uint256 public totalWeight;
@@ -773,6 +773,24 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     mapping(address => address[]) public tokenVote; // msg.sender => token
     mapping(address => uint256) public usedWeights; // msg.sender => total voting weight of user
 
+    uint256 public constant week = 7 days;
+    uint256 public firstDistribution; // epoch time stamp
+    uint256 public prevDistributionId;
+    uint256 public currentId;
+    mapping(uint256 => mapping(address => mapping(address => uint256)))
+        public ballot; // id(block.timestamp) => votes
+
+    modifier epochDistribute() {
+        uint256 time = block.timestamp -
+            (prevDistributionId * 604800) +
+            firstDistribution;
+        require(
+            time > week,
+            "GaugeProxyV2: distribution already done for this week"
+        );
+        _;
+    }
+
     function tokens() external view returns (address[] memory) {
         return _tokens;
     }
@@ -781,9 +799,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         return gauges[_token];
     }
 
-    function initialize() public initializer {
-        // TOKEN = IERC20(address(new MasterDill()));
+    function initialize(uint256 _firstDistribution) public initializer {
+        TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
+        firstDistribution = _firstDistribution;
     }
 
     // Reset votes to 0
@@ -793,6 +812,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Reset votes to 0
     function _reset(address _owner) internal {
+        // lastVote[_owner] = 0;
         address[] storage _tokenVote = tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
 
@@ -852,11 +872,19 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             );
 
             if (_gauge != address(0x0)) {
+                if (
+                    (firstDistribution + (currentId * 604800)) > block.timestamp
+                ) {
+                    currentId += 1;
+                }
                 _usedWeight = _usedWeight.add(_tokenWeight);
                 totalWeight = totalWeight.add(_tokenWeight);
                 weights[_token] = weights[_token].add(_tokenWeight);
                 tokenVote[_owner].push(_token);
                 votes[_owner][_token] = _tokenWeight;
+                // check if voting cycle is over then update ballotId
+                // add uers vote to ballot
+                ballot[currentId][_owner][_token] = _tokenWeight;
             }
         }
 
@@ -869,6 +897,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     {
         require(_tokenVote.length == _weights.length);
         _vote(msg.sender, _tokenVote, _weights);
+        // lastVote[msg.sender] = block.timestamp;
     }
 
     // Add new token gauge
@@ -908,13 +937,21 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         return _tokens.length;
     }
 
-    function distribute(uint256 _start, uint256 _end) external {
+    function distribute(uint256 _start, uint256 _end) external epochDistribute {
+        require(_start < _end, "GaugeProxyV2: bad _start");
+        require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
+        require(
+            msg.sender == governance,
+            "GaugeProxyV2: only governance can distribute"
+        );
+        if (_tokens.length == _end) {
+            prevDistributionId += 1;
+        }
+        require(prevDistributionId < currentId,"GaugeProxyV2: voting for current period in progress");
         collect();
-        require(_start < _end, "bad _start");
-        require(_end <= _tokens.length, "bad _end");
         uint256 _balance = PICKLE.balanceOf(address(this));
         if (_balance > 0 && totalWeight > 0) {
-            for (uint256 i = 0; i < _tokens.length; i++) {
+            for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
                 uint256 _reward = _balance.mul(weights[_token]).div(
diff --git a/src/dill/scripts/deploy_gauge_proxy_V2.js b/src/dill/scripts/deploy_gauge_proxy_V2.js
index ccf52f120..a1e2935c1 100644
--- a/src/dill/scripts/deploy_gauge_proxy_V2.js
+++ b/src/dill/scripts/deploy_gauge_proxy_V2.js
@@ -1,15 +1,26 @@
 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");
+  const gaugeProxyV2 = await ethers.getContractFactory(
+    "contracts/gauge-proxy-v2.sol:GaugeProxyV2"
+  );
   console.log("Deploying GaugeProxyV2...");
-  const GaugeProxyV2 = await upgrades.deployProxy(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) => {
diff --git a/src/dill/scripts/upgrade_gauge_proxy_v2.js b/src/dill/scripts/upgrade_gauge_proxy_v2.js
index 3e8f7e742..cd3de8c40 100644
--- a/src/dill/scripts/upgrade_gauge_proxy_v2.js
+++ b/src/dill/scripts/upgrade_gauge_proxy_v2.js
@@ -1,13 +1,25 @@
 const { ethers, upgrades } = require("hardhat");
 
 async function main() {
-  const GaugeProxyV2 = await ethers.getContractFactory("gaugeProxyV2");
+  console.log("Getting contract...");
+  const GaugeProxyV2 = await ethers.getContractFactory(
+    "contracts/gauge-proxy-v2.sol:GaugeProxyV2"
+  );
   console.log("Upgrading GaugeProxy...");
-  await upgrades.upgradeProxy(
-    "",
+  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();
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

From 42e3521f17bdf03fabb02688611756ed32dafd2f Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 31 Mar 2022 10:56:55 +0530
Subject: [PATCH 03/55] fix: periodized totalWeight

---
 src/dill/gauge-proxy-v2.sol | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index f4f7d8787..20ab1aafb 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -778,7 +778,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public prevDistributionId;
     uint256 public currentId;
     mapping(uint256 => mapping(address => mapping(address => uint256)))
-        public ballot; // id(block.timestamp) => votes
+        public ballot; // periodId => votes
+    mapping(uint256 => uint256) public totalWeightsPerPeriod; // periodId => totalWeight
 
     modifier epochDistribute() {
         uint256 time = block.timestamp -
@@ -844,7 +845,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             uint256 _prevWeight = votes[_owner][_tokenVote[i]];
             _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
         }
-
         _vote(_owner, _tokenVote, _weights);
     }
 
@@ -872,6 +872,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             );
 
             if (_gauge != address(0x0)) {
+                // check if voting cycle is over then update ballotId
                 if (
                     (firstDistribution + (currentId * 604800)) > block.timestamp
                 ) {
@@ -882,7 +883,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 weights[_token] = weights[_token].add(_tokenWeight);
                 tokenVote[_owner].push(_token);
                 votes[_owner][_token] = _tokenWeight;
-                // check if voting cycle is over then update ballotId
+                totalWeightsPerPeriod[currentId] = totalWeight;
                 // add uers vote to ballot
                 ballot[currentId][_owner][_token] = _tokenWeight;
             }
@@ -947,15 +948,19 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         if (_tokens.length == _end) {
             prevDistributionId += 1;
         }
-        require(prevDistributionId < currentId,"GaugeProxyV2: voting for current period in progress");
+        require(
+            prevDistributionId < currentId,
+            "GaugeProxyV2: voting for current period in progress"
+        );
         collect();
         uint256 _balance = PICKLE.balanceOf(address(this));
-        if (_balance > 0 && totalWeight > 0) {
+        uint256 _totalWeight = totalWeightsPerPeriod[currentId];
+        if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
                 uint256 _reward = _balance.mul(weights[_token]).div(
-                    totalWeight
+                    _totalWeight
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);

From 7394d85a168c583db31ef8d7da303a26d6cc4b0c Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 31 Mar 2022 19:17:54 +0530
Subject: [PATCH 04/55] added periodization to weights

---
 src/dill/gauge-proxy-v2.sol | 39 +++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 20ab1aafb..b278fd634 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -777,9 +777,17 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public firstDistribution; // epoch time stamp
     uint256 public prevDistributionId;
     uint256 public currentId;
-    mapping(uint256 => mapping(address => mapping(address => uint256)))
-        public ballot; // periodId => votes
-    mapping(uint256 => uint256) public totalWeightsPerPeriod; // periodId => totalWeight
+
+    // mapping(uint256 => mapping(address => mapping(address => uint256))) public ballot; // periodId => votes
+    // mapping(uint256 => mapping(address => uint256)) public weightsPerPeriod; // periodId => weights
+    // mapping(uint256 => uint256) public totalWeightsPerPeriod; // periodId => totalWeight
+
+    struct periodData {
+        mapping(address => mapping(address => uint256)) votes_;
+        mapping(address => uint256) weights_;
+        uint256 totalWeight_;
+    }
+    mapping(uint256 => periodData) public periods; // periodId => periodData
 
     modifier epochDistribute() {
         uint256 time = block.timestamp -
@@ -883,9 +891,17 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 weights[_token] = weights[_token].add(_tokenWeight);
                 tokenVote[_owner].push(_token);
                 votes[_owner][_token] = _tokenWeight;
-                totalWeightsPerPeriod[currentId] = totalWeight;
-                // add uers vote to ballot
-                ballot[currentId][_owner][_token] = _tokenWeight;
+                // store weights of current period
+                // weightsPerPeriod[currentId][_token] = weights[_token]; 
+                periods[currentId].weights_[_token] = weights[_token];
+
+                // store total weight of current period
+                // totalWeightsPerPeriod[currentId] = totalWeight;
+                periods[currentId].totalWeight_ = totalWeight;
+
+                // add users vote to ballot
+                // ballot[currentId][_owner][_token] = _tokenWeight;
+                periods[currentId].votes_[_owner][_token] = _tokenWeight;
             }
         }
 
@@ -941,10 +957,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function distribute(uint256 _start, uint256 _end) external epochDistribute {
         require(_start < _end, "GaugeProxyV2: bad _start");
         require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
-        require(
-            msg.sender == governance,
-            "GaugeProxyV2: only governance can distribute"
-        );
+        require(msg.sender == governance,"GaugeProxyV2: only governance can distribute");
         if (_tokens.length == _end) {
             prevDistributionId += 1;
         }
@@ -954,12 +967,14 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         );
         collect();
         uint256 _balance = PICKLE.balanceOf(address(this));
-        uint256 _totalWeight = totalWeightsPerPeriod[currentId];
+        periodData storage _periodData = periods[prevDistributionId + 1];
+        // uint256 _totalWeight = totalWeightsPerPeriod[prevDistributionId + 1];
+        uint256 _totalWeight = _periodData.totalWeight_;
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
-                uint256 _reward = _balance.mul(weights[_token]).div(
+                uint256 _reward = _balance.mul(_periodData.weights_[_token]).div(
                     _totalWeight
                 );
                 if (_reward > 0) {

From 1668db676cf3fcfa6018e7c1c4baafeb14ab831a Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 31 Mar 2022 22:02:36 +0530
Subject: [PATCH 05/55] fix: updated currentId increment

---
 src/dill/gauge-proxy-v2.sol | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index b278fd634..58d1163c6 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -778,10 +778,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public prevDistributionId;
     uint256 public currentId;
 
-    // mapping(uint256 => mapping(address => mapping(address => uint256))) public ballot; // periodId => votes
-    // mapping(uint256 => mapping(address => uint256)) public weightsPerPeriod; // periodId => weights
-    // mapping(uint256 => uint256) public totalWeightsPerPeriod; // periodId => totalWeight
-
     struct periodData {
         mapping(address => mapping(address => uint256)) votes_;
         mapping(address => uint256) weights_;
@@ -868,6 +864,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         uint256 _totalVoteWeight = 0;
         uint256 _usedWeight = 0;
 
+        // check if voting cycle is over then update ballotId
+        if (
+            (firstDistribution + (currentId * 604800)) > block.timestamp
+        ) {
+            currentId += 1;
+        }
         for (uint256 i = 0; i < _tokenCnt; i++) {
             _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
         }
@@ -880,27 +882,16 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             );
 
             if (_gauge != address(0x0)) {
-                // check if voting cycle is over then update ballotId
-                if (
-                    (firstDistribution + (currentId * 604800)) > block.timestamp
-                ) {
-                    currentId += 1;
-                }
                 _usedWeight = _usedWeight.add(_tokenWeight);
                 totalWeight = totalWeight.add(_tokenWeight);
                 weights[_token] = weights[_token].add(_tokenWeight);
                 tokenVote[_owner].push(_token);
                 votes[_owner][_token] = _tokenWeight;
                 // store weights of current period
-                // weightsPerPeriod[currentId][_token] = weights[_token]; 
                 periods[currentId].weights_[_token] = weights[_token];
-
                 // store total weight of current period
-                // totalWeightsPerPeriod[currentId] = totalWeight;
                 periods[currentId].totalWeight_ = totalWeight;
-
                 // add users vote to ballot
-                // ballot[currentId][_owner][_token] = _tokenWeight;
                 periods[currentId].votes_[_owner][_token] = _tokenWeight;
             }
         }
@@ -914,7 +905,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     {
         require(_tokenVote.length == _weights.length);
         _vote(msg.sender, _tokenVote, _weights);
-        // lastVote[msg.sender] = block.timestamp;
     }
 
     // Add new token gauge
@@ -968,7 +958,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         collect();
         uint256 _balance = PICKLE.balanceOf(address(this));
         periodData storage _periodData = periods[prevDistributionId + 1];
-        // uint256 _totalWeight = totalWeightsPerPeriod[prevDistributionId + 1];
         uint256 _totalWeight = _periodData.totalWeight_;
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {

From b373608b43581a3b013f7654acbea4ef6bf5e418 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 1 Apr 2022 16:55:52 +0530
Subject: [PATCH 06/55] chore: refactoring and logic improvements

---
 src/dill/gauge-proxy-v2.sol | 80 ++++++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 58d1163c6..2bb812063 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -764,30 +764,28 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     IERC20 public TOKEN;
 
     uint256 public pid;
-    uint256 public totalWeight;
 
     address[] internal _tokens;
     mapping(address => address) public gauges; // token => gauge
-    mapping(address => uint256) public weights; // token => weight
-    mapping(address => mapping(address => uint256)) public votes; // msg.sender => votes
-    mapping(address => address[]) public tokenVote; // msg.sender => token
-    mapping(address => uint256) public usedWeights; // msg.sender => total voting weight of user
 
     uint256 public constant week = 7 days;
+    uint256 public constant weekSeconds = 604800;
     uint256 public firstDistribution; // epoch time stamp
     uint256 public prevDistributionId;
     uint256 public currentId;
 
     struct periodData {
-        mapping(address => mapping(address => uint256)) votes_;
-        mapping(address => uint256) weights_;
-        uint256 totalWeight_;
+        mapping(address => mapping(address => uint256)) votes; // msg.sender => votes
+        mapping(address => uint256) weights; // token => weight
+        mapping(address => address[]) tokenVote; // msg.sender => token
+        mapping(address => uint256) usedWeights; // msg.sender => total voting weight of user
+        uint256 totalWeight;
     }
     mapping(uint256 => periodData) public periods; // periodId => periodData
 
     modifier epochDistribute() {
         uint256 time = block.timestamp -
-            (prevDistributionId * 604800) +
+            (prevDistributionId * weekSeconds) +
             firstDistribution;
         require(
             time > week,
@@ -817,36 +815,50 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Reset votes to 0
     function _reset(address _owner) internal {
+        if (
+            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
+        ) {
+            currentId += 1;
+        }
+        periodData storage _periodData = periods[currentId];
+
         // lastVote[_owner] = 0;
-        address[] storage _tokenVote = tokenVote[_owner];
+        address[] storage _tokenVote = _periodData.tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
 
         for (uint256 i = 0; i < _tokenVoteCnt; i++) {
             address _token = _tokenVote[i];
-            uint256 _votes = votes[_owner][_token];
+            uint256 _votes = _periodData.votes[_owner][_token];
 
             if (_votes > 0) {
-                totalWeight = totalWeight.sub(_votes);
-                weights[_token] = weights[_token].sub(_votes);
+                _periodData.totalWeight = _periodData.totalWeight.sub(_votes);
+                _periodData.weights[_token] = _periodData.weights[_token].sub(_votes);
 
-                votes[_owner][_token] = 0;
+                _periodData.votes[_owner][_token] = 0;
             }
         }
 
-        delete tokenVote[_owner];
+        delete _periodData.tokenVote[_owner];
     }
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
     function poke(address _owner) public {
-        address[] memory _tokenVote = tokenVote[_owner];
+        if (
+            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
+        ) {
+            currentId += 1;
+        }
+        periodData storage _periodData = periods[currentId];
+
+        address[] memory _tokenVote = _periodData.tokenVote[_owner];
         uint256 _tokenCnt = _tokenVote.length;
         uint256[] memory _weights = new uint256[](_tokenCnt);
 
-        uint256 _prevUsedWeight = usedWeights[_owner];
+        uint256 _prevUsedWeight = _periodData.usedWeights[_owner];
         uint256 _weight = DILL.balanceOf(_owner);
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            uint256 _prevWeight = votes[_owner][_tokenVote[i]];
+            uint256 _prevWeight = _periodData.votes[_owner][_tokenVote[i]];
             _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
         }
         _vote(_owner, _tokenVote, _weights);
@@ -866,14 +878,17 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         // check if voting cycle is over then update ballotId
         if (
-            (firstDistribution + (currentId * 604800)) > block.timestamp
+            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
         ) {
             currentId += 1;
         }
+
         for (uint256 i = 0; i < _tokenCnt; i++) {
             _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
         }
 
+        periodData storage _periodData = periods[currentId];
+
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
@@ -883,20 +898,20 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
             if (_gauge != address(0x0)) {
                 _usedWeight = _usedWeight.add(_tokenWeight);
-                totalWeight = totalWeight.add(_tokenWeight);
-                weights[_token] = weights[_token].add(_tokenWeight);
-                tokenVote[_owner].push(_token);
-                votes[_owner][_token] = _tokenWeight;
+                _periodData.totalWeight = _periodData.totalWeight.add(_tokenWeight);
+                // weights[_token] = weights[_token].add(_tokenWeight);
+                _periodData.tokenVote[_owner].push(_token);
+                // votes[_owner][_token] = _tokenWeight;
                 // store weights of current period
-                periods[currentId].weights_[_token] = weights[_token];
+                _periodData.weights[_token] = _periodData.weights[_token].add(_tokenWeight);
                 // store total weight of current period
-                periods[currentId].totalWeight_ = totalWeight;
+                _periodData.totalWeight = _periodData.totalWeight;
                 // add users vote to ballot
-                periods[currentId].votes_[_owner][_token] = _tokenWeight;
+                _periodData.votes[_owner][_token] = _tokenWeight;
             }
         }
 
-        usedWeights[_owner] = _usedWeight;
+        _periodData.usedWeights[_owner] = _usedWeight;
     }
 
     // Vote with DILL on a gauge
@@ -948,9 +963,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(_start < _end, "GaugeProxyV2: bad _start");
         require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
         require(msg.sender == governance,"GaugeProxyV2: only governance can distribute");
-        if (_tokens.length == _end) {
-            prevDistributionId += 1;
-        }
         require(
             prevDistributionId < currentId,
             "GaugeProxyV2: voting for current period in progress"
@@ -958,12 +970,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         collect();
         uint256 _balance = PICKLE.balanceOf(address(this));
         periodData storage _periodData = periods[prevDistributionId + 1];
-        uint256 _totalWeight = _periodData.totalWeight_;
+        uint256 _totalWeight = _periodData.totalWeight;
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
-                uint256 _reward = _balance.mul(_periodData.weights_[_token]).div(
+                uint256 _reward = _balance.mul(_periodData.weights[_token]).div(
                     _totalWeight
                 );
                 if (_reward > 0) {
@@ -973,5 +985,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 }
             }
         }
+    
+        if (_tokens.length == _end) {
+            prevDistributionId += 1;
+        }
     }
 }

From 2120853b32ba591905851482b301eed8fd6f43dd Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Mon, 4 Apr 2022 10:58:49 +0530
Subject: [PATCH 07/55] chore: more refactoring of ballot id updation

---
 src/dill/gauge-proxy-v2.sol | 48 ++++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 2bb812063..ced4b140f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -810,16 +810,15 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Reset votes to 0
     function reset() external {
+        // check if voting cycle is over then update ballotId
+        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
+            currentId += 1;
+        }
         _reset(msg.sender);
     }
 
     // Reset votes to 0
     function _reset(address _owner) internal {
-        if (
-            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
-        ) {
-            currentId += 1;
-        }
         periodData storage _periodData = periods[currentId];
 
         // lastVote[_owner] = 0;
@@ -832,7 +831,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
             if (_votes > 0) {
                 _periodData.totalWeight = _periodData.totalWeight.sub(_votes);
-                _periodData.weights[_token] = _periodData.weights[_token].sub(_votes);
+                _periodData.weights[_token] = _periodData.weights[_token].sub(
+                    _votes
+                );
 
                 _periodData.votes[_owner][_token] = 0;
             }
@@ -843,9 +844,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
     function poke(address _owner) public {
-        if (
-            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
-        ) {
+        // check if voting cycle is over then update ballotId
+        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
             currentId += 1;
         }
         periodData storage _periodData = periods[currentId];
@@ -876,13 +876,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         uint256 _totalVoteWeight = 0;
         uint256 _usedWeight = 0;
 
-        // check if voting cycle is over then update ballotId
-        if (
-            (firstDistribution + (currentId * weekSeconds)) > block.timestamp
-        ) {
-            currentId += 1;
-        }
-
         for (uint256 i = 0; i < _tokenCnt; i++) {
             _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
         }
@@ -898,12 +891,14 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
             if (_gauge != address(0x0)) {
                 _usedWeight = _usedWeight.add(_tokenWeight);
-                _periodData.totalWeight = _periodData.totalWeight.add(_tokenWeight);
-                // weights[_token] = weights[_token].add(_tokenWeight);
+                _periodData.totalWeight = _periodData.totalWeight.add(
+                    _tokenWeight
+                );
                 _periodData.tokenVote[_owner].push(_token);
-                // votes[_owner][_token] = _tokenWeight;
                 // store weights of current period
-                _periodData.weights[_token] = _periodData.weights[_token].add(_tokenWeight);
+                _periodData.weights[_token] = _periodData.weights[_token].add(
+                    _tokenWeight
+                );
                 // store total weight of current period
                 _periodData.totalWeight = _periodData.totalWeight;
                 // add users vote to ballot
@@ -919,6 +914,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         external
     {
         require(_tokenVote.length == _weights.length);
+
+        // check if voting cycle is over then update ballotId
+        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
+            currentId += 1;
+        }
+
         _vote(msg.sender, _tokenVote, _weights);
     }
 
@@ -962,7 +963,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function distribute(uint256 _start, uint256 _end) external epochDistribute {
         require(_start < _end, "GaugeProxyV2: bad _start");
         require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
-        require(msg.sender == governance,"GaugeProxyV2: only governance can distribute");
+        require(
+            msg.sender == governance,
+            "GaugeProxyV2: only governance can distribute"
+        );
         require(
             prevDistributionId < currentId,
             "GaugeProxyV2: voting for current period in progress"
@@ -985,7 +989,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 }
             }
         }
-    
+
         if (_tokens.length == _end) {
             prevDistributionId += 1;
         }

From 3a465a8f73c04630deda13da3cf19c829261a818 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Mon, 4 Apr 2022 19:15:51 +0530
Subject: [PATCH 08/55] feat: censoring Gauges

---
 src/dill/gauge-proxy-v2.sol | 159 ++++++++++++++++++++++++++++--------
 1 file changed, 126 insertions(+), 33 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index ced4b140f..0c0b33c59 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -80,6 +80,70 @@ library SafeMath {
     }
 }
 
+/**
+ * @dev Wrappers over Solidity's arithmetic operations.
+ *
+ * NOTE: `SignedSafeMath` is no longer needed starting with Solidity 0.8. The compiler
+ * now has built in overflow checking.
+ */
+library SignedSafeMath {
+    /**
+     * @dev Returns the multiplication of two signed integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `*` operator.
+     *
+     * Requirements:
+     *
+     * - Multiplication cannot overflow.
+     */
+    function mul(int256 a, int256 b) internal pure returns (int256) {
+        return a * b;
+    }
+
+    /**
+     * @dev Returns the integer division of two signed integers. Reverts on
+     * division by zero. The result is rounded towards zero.
+     *
+     * Counterpart to Solidity's `/` operator.
+     *
+     * Requirements:
+     *
+     * - The divisor cannot be zero.
+     */
+    function div(int256 a, int256 b) internal pure returns (int256) {
+        return a / b;
+    }
+
+    /**
+     * @dev Returns the subtraction of two signed integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `-` operator.
+     *
+     * Requirements:
+     *
+     * - Subtraction cannot overflow.
+     */
+    function sub(int256 a, int256 b) internal pure returns (int256) {
+        return a - b;
+    }
+
+    /**
+     * @dev Returns the addition of two signed integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `+` operator.
+     *
+     * Requirements:
+     *
+     * - Addition cannot overflow.
+     */
+    function add(int256 a, int256 b) internal pure returns (int256) {
+        return a + b;
+    }
+}
+
 library Address {
     function isContract(address account) internal view returns (bool) {
         bytes32 codehash;
@@ -752,6 +816,7 @@ contract Initializable {
 
 contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     using SafeMath for uint256;
+    using SignedSafeMath for int256;
     using SafeERC20 for IERC20;
 
     MasterChef public constant MASTER =
@@ -767,6 +832,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     address[] internal _tokens;
     mapping(address => address) public gauges; // token => gauge
+    mapping(address => mapping(address => uint256))
+        public gaugeWithNegativeWeight;
 
     uint256 public constant week = 7 days;
     uint256 public constant weekSeconds = 604800;
@@ -775,11 +842,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public currentId;
 
     struct periodData {
-        mapping(address => mapping(address => uint256)) votes; // msg.sender => votes
-        mapping(address => uint256) weights; // token => weight
+        mapping(address => mapping(address => int256)) votes; // msg.sender => votes
+        mapping(address => int256) weights; // token => weight
         mapping(address => address[]) tokenVote; // msg.sender => token
-        mapping(address => uint256) usedWeights; // msg.sender => total voting weight of user
-        uint256 totalWeight;
+        mapping(address => int256) usedWeights; // msg.sender => total voting weight of user
+        int256 totalWeight;
     }
     mapping(uint256 => periodData) public periods; // periodId => periodData
 
@@ -808,12 +875,28 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         firstDistribution = _firstDistribution;
     }
 
+    function _updateCurrentId() internal {
+        uint256 lastPeriodTimestamp = (firstDistribution +
+            (currentId * weekSeconds));
+        uint256 prevPeriodId;
+        if (lastPeriodTimestamp < block.timestamp) {
+            uint256 weeksElapsed = (block.timestamp - lastPeriodTimestamp) /
+                60 /
+                60 /
+                24 /
+                7;
+            prevPeriodId = currentId;
+            currentId = currentId + weeksElapsed + 1;
+            for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
+                periods[i] = periods[i - 1];
+            }
+        }
+    }
+
     // Reset votes to 0
     function reset() external {
         // check if voting cycle is over then update ballotId
-        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
-            currentId += 1;
-        }
+        _updateCurrentId();
         _reset(msg.sender);
     }
 
@@ -827,7 +910,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         for (uint256 i = 0; i < _tokenVoteCnt; i++) {
             address _token = _tokenVote[i];
-            uint256 _votes = _periodData.votes[_owner][_token];
+            int256 _votes = _periodData.votes[_owner][_token];
 
             if (_votes > 0) {
                 _periodData.totalWeight = _periodData.totalWeight.sub(_votes);
@@ -844,21 +927,18 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
     function poke(address _owner) public {
-        // check if voting cycle is over then update ballotId
-        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
-            currentId += 1;
-        }
+        _updateCurrentId();
         periodData storage _periodData = periods[currentId];
 
         address[] memory _tokenVote = _periodData.tokenVote[_owner];
         uint256 _tokenCnt = _tokenVote.length;
-        uint256[] memory _weights = new uint256[](_tokenCnt);
+        int256[] memory _weights = new int256[](_tokenCnt);
 
-        uint256 _prevUsedWeight = _periodData.usedWeights[_owner];
-        uint256 _weight = DILL.balanceOf(_owner);
+        int256 _prevUsedWeight = _periodData.usedWeights[_owner];
+        int256 _weight = int256(DILL.balanceOf(_owner));
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            uint256 _prevWeight = _periodData.votes[_owner][_tokenVote[i]];
+            int256 _prevWeight = _periodData.votes[_owner][_tokenVote[i]];
             _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
         }
         _vote(_owner, _tokenVote, _weights);
@@ -867,17 +947,19 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function _vote(
         address _owner,
         address[] memory _tokenVote,
-        uint256[] memory _weights
+        int256[] memory _weights
     ) internal {
         // _weights[i] = percentage * 100
         _reset(_owner);
         uint256 _tokenCnt = _tokenVote.length;
-        uint256 _weight = DILL.balanceOf(_owner);
-        uint256 _totalVoteWeight = 0;
-        uint256 _usedWeight = 0;
+        int256 _weight = int256(DILL.balanceOf(_owner));
+        int256 _totalVoteWeight = 0;
+        int256 _usedWeight = 0;
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
+            _totalVoteWeight = _totalVoteWeight.add(
+                _weights[i] > 0 ? _weights[i] : -_weights[i]
+            );
         }
 
         periodData storage _periodData = periods[currentId];
@@ -885,7 +967,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
-            uint256 _tokenWeight = _weights[i].mul(_weight).div(
+            int256 _tokenWeight = _weights[i].mul(_weight).div(
                 _totalVoteWeight
             );
 
@@ -910,16 +992,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     // Vote with DILL on a gauge
-    function vote(address[] calldata _tokenVote, uint256[] calldata _weights)
+    function vote(address[] calldata _tokenVote, int256[] calldata _weights)
         external
     {
         require(_tokenVote.length == _weights.length);
-
-        // check if voting cycle is over then update ballotId
-        if ((firstDistribution + (currentId * weekSeconds)) > block.timestamp) {
-            currentId += 1;
-        }
-
+        _updateCurrentId();
         _vote(msg.sender, _tokenVote, _weights);
     }
 
@@ -931,6 +1008,20 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         _tokens.push(_token);
     }
 
+    function removeAllCensoredGauges() external {
+        require(
+            msg.sender == governance,
+            "GaugeProxyV2: only governance can delist gauge"
+        );
+        for (uint256 i = 0; i < _tokens.length; i++) {
+            address _token = _tokens[i];
+            address _gauge = gauges[_token];
+            if (gaugeWithNegativeWeight[_token][_gauge] >= 5) {
+                gauges[_token] = address(0x0);
+            }
+        }
+    }
+
     // Sets MasterChef PID
     function setPID(uint256 _pid) external {
         require(msg.sender == governance, "!gov");
@@ -972,20 +1063,22 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "GaugeProxyV2: voting for current period in progress"
         );
         collect();
-        uint256 _balance = PICKLE.balanceOf(address(this));
+        int256 _balance = int256(PICKLE.balanceOf(address(this)));
         periodData storage _periodData = periods[prevDistributionId + 1];
-        uint256 _totalWeight = _periodData.totalWeight;
+        int256 _totalWeight = _periodData.totalWeight;
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
-                uint256 _reward = _balance.mul(_periodData.weights[_token]).div(
-                    _totalWeight
+                uint256 _reward = uint256(
+                    _balance.mul(_periodData.weights[_token]).div(_totalWeight)
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, _reward);
                     Gauge(_gauge).notifyRewardAmount(_reward);
+                } else if (_reward < 0) {
+                    gaugeWithNegativeWeight[_token][_gauge] += 1;
                 }
             }
         }

From 05fe6298f3c8dedccfb8f16f18b40f6cfa835622 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 5 Apr 2022 14:42:04 +0530
Subject: [PATCH 09/55] feat: added more features for censorship

---
 src/dill/gauge-proxy-v2.sol | 117 ++++++++++++++++++++----------------
 1 file changed, 65 insertions(+), 52 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 0c0b33c59..dee2063fe 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -832,14 +832,13 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     address[] internal _tokens;
     mapping(address => address) public gauges; // token => gauge
-    mapping(address => mapping(address => uint256))
-        public gaugeWithNegativeWeight;
+    mapping(address => uint256) public gaugeWithNegativeWeight;
 
     uint256 public constant week = 7 days;
     uint256 public constant weekSeconds = 604800;
     uint256 public firstDistribution; // epoch time stamp
-    uint256 public prevDistributionId;
-    uint256 public currentId;
+    uint256 public prevDistributionId = 0;
+    uint256 public currentId = 1;
 
     struct periodData {
         mapping(address => mapping(address => int256)) votes; // msg.sender => votes
@@ -850,15 +849,18 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
     mapping(uint256 => periodData) public periods; // periodId => periodData
 
-    modifier epochDistribute() {
-        uint256 time = block.timestamp -
-            (prevDistributionId * weekSeconds) +
-            firstDistribution;
-        require(
-            time > week,
-            "GaugeProxyV2: distribution already done for this week"
-        );
-        _;
+    function getActualCurrentPeriodId() public view returns (uint256) {
+        uint256 lastPeriodEndTimestamp = (firstDistribution +
+            (currentId * weekSeconds));
+        if (lastPeriodEndTimestamp < block.timestamp) {
+            uint256 weeksElapsed = (block.timestamp - lastPeriodEndTimestamp) /
+                60 /
+                60 /
+                24 /
+                7;
+
+            return currentId + weeksElapsed + 1;
+        }
     }
 
     function tokens() external view returns (address[] memory) {
@@ -876,20 +878,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     function _updateCurrentId() internal {
-        uint256 lastPeriodTimestamp = (firstDistribution +
-            (currentId * weekSeconds));
-        uint256 prevPeriodId;
-        if (lastPeriodTimestamp < block.timestamp) {
-            uint256 weeksElapsed = (block.timestamp - lastPeriodTimestamp) /
-                60 /
-                60 /
-                24 /
-                7;
-            prevPeriodId = currentId;
-            currentId = currentId + weeksElapsed + 1;
-            for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
-                periods[i] = periods[i - 1];
-            }
+        uint256 prevPeriodId = currentId;
+        currentId = getActualCurrentPeriodId();
+        for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
+            periods[i] = periods[i - 1];
         }
     }
 
@@ -912,8 +904,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             address _token = _tokenVote[i];
             int256 _votes = _periodData.votes[_owner][_token];
 
-            if (_votes > 0) {
-                _periodData.totalWeight = _periodData.totalWeight.sub(_votes);
+            if (_votes != 0) {
+                _periodData.totalWeight = _periodData.totalWeight.sub(
+                    _votes > 0 ? _votes : -_votes
+                );
                 _periodData.weights[_token] = _periodData.weights[_token].sub(
                     _votes
                 );
@@ -949,7 +943,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] memory _tokenVote,
         int256[] memory _weights
     ) internal {
-        // _weights[i] = percentage * 100
         _reset(_owner);
         uint256 _tokenCnt = _tokenVote.length;
         int256 _weight = int256(DILL.balanceOf(_owner));
@@ -972,19 +965,20 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             );
 
             if (_gauge != address(0x0)) {
-                _usedWeight = _usedWeight.add(_tokenWeight);
-                _periodData.totalWeight = _periodData.totalWeight.add(
+                _periodData.weights[_token] = _periodData.weights[_token].add(
                     _tokenWeight
                 );
+                _periodData.votes[_owner][_token] = _tokenWeight;
                 _periodData.tokenVote[_owner].push(_token);
-                // store weights of current period
-                _periodData.weights[_token] = _periodData.weights[_token].add(
+
+                if (_tokenWeight < 0) {
+                    _tokenWeight = -_tokenWeight;
+                }
+
+                _usedWeight = _usedWeight.add(_tokenWeight);
+                _periodData.totalWeight = _periodData.totalWeight.add(
                     _tokenWeight
                 );
-                // store total weight of current period
-                _periodData.totalWeight = _periodData.totalWeight;
-                // add users vote to ballot
-                _periodData.votes[_owner][_token] = _tokenWeight;
             }
         }
 
@@ -1008,18 +1002,31 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         _tokens.push(_token);
     }
 
-    function removeAllCensoredGauges() external {
+    function delistGauge(address _token) external {
+        require(msg.sender == governance, "!gov");
+        require(gauges[_token] != address(0x0), "!exists");
+
+        uint256 _actualCurrentId = getActualCurrentPeriodId();
         require(
-            msg.sender == governance,
-            "GaugeProxyV2: only governance can delist gauge"
+            prevDistributionId == _actualCurrentId - 1,
+            "! all distributions completed"
         );
-        for (uint256 i = 0; i < _tokens.length; i++) {
-            address _token = _tokens[i];
-            address _gauge = gauges[_token];
-            if (gaugeWithNegativeWeight[_token][_gauge] >= 5) {
-                gauges[_token] = address(0x0);
-            }
+
+        address _gauge = gauges[_token];
+
+        require(gaugeWithNegativeWeight[_gauge] >= 5, "censors < 5");
+
+        delete gauges[_token];
+
+        address[] storage newTokenArray;
+        uint256 tokensLength = _tokens.length;
+
+        for (uint i = 0; i < tokensLength; i++){
+            if(_tokens[i] != _token)
+                newTokenArray.push(_tokens[i]);
         }
+
+        _tokens = newTokenArray;
     }
 
     // Sets MasterChef PID
@@ -1051,17 +1058,21 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         return _tokens.length;
     }
 
-    function distribute(uint256 _start, uint256 _end) external epochDistribute {
+    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"
         );
+
+        _updateCurrentId();
+
         require(
-            prevDistributionId < currentId,
-            "GaugeProxyV2: voting for current period in progress"
+            prevDistributionId < currentId - 1,
+            "GaugeProxyV2: all period distributions complete"
         );
+
         collect();
         int256 _balance = int256(PICKLE.balanceOf(address(this)));
         periodData storage _periodData = periods[prevDistributionId + 1];
@@ -1077,8 +1088,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, _reward);
                     Gauge(_gauge).notifyRewardAmount(_reward);
-                } else if (_reward < 0) {
-                    gaugeWithNegativeWeight[_token][_gauge] += 1;
+                }
+
+                if (_reward < 0) {
+                    gaugeWithNegativeWeight[_gauge] += 1;
                 }
             }
         }

From f9a7be35562b727b8841b2ded47cd34b15449c65 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 6 Apr 2022 17:04:06 +0530
Subject: [PATCH 10/55] feat: deligation of votes

---
 src/dill/gauge-proxy-v2.sol | 41 +++++++++++++++++++++++++++++++++++--
 1 file changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index dee2063fe..8bf207772 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -837,8 +837,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public constant week = 7 days;
     uint256 public constant weekSeconds = 604800;
     uint256 public firstDistribution; // epoch time stamp
-    uint256 public prevDistributionId = 0;
-    uint256 public currentId = 1;
+    uint256 public prevDistributionId;
+    uint256 public currentId;
 
     struct periodData {
         mapping(address => mapping(address => int256)) votes; // msg.sender => votes
@@ -849,6 +849,24 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
     mapping(uint256 => periodData) public periods; // periodId => periodData
 
+    struct deligateData {
+        address deligate;
+        uint256 periods;
+        bool canVoteForCurrentPeriod;
+    }
+    mapping (address => deligateData) public deligations;
+    // no. of periods 0 = none, 1 = indefinate , n = n-1 periods
+
+    function setVotingDelicate(address _delicate, uint256 _periodsCount) public {
+        require(_delicate != address(0), "GaugeProxyV2: cannot delicate zero address");
+        require(_delicate != msg.sender, "GaugeProxyV2: delicating address cannot be delicated");
+        deligations[msg.sender].deligate = _delicate;
+        deligations[msg.sender].canVoteForCurrentPeriod = true;
+        if( _periodCount > 1) {
+            deligations[msg.sender].periods = _periodsCount + 1;
+        }
+    }
+
     function getActualCurrentPeriodId() public view returns (uint256) {
         uint256 lastPeriodEndTimestamp = (firstDistribution +
             (currentId * weekSeconds));
@@ -875,6 +893,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
         firstDistribution = _firstDistribution;
+        currentId = 1;
+        prevDistributionId = 0;
     }
 
     function _updateCurrentId() internal {
@@ -992,6 +1012,23 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(_tokenVote.length == _weights.length);
         _updateCurrentId();
         _vote(msg.sender, _tokenVote, _weights);
+        deligations[msg.sender].canVoteForCurrentPeriod = false;
+    }
+
+    function voteFor(address _owner, address[] calldata _tokenVote, int256[] calldata _weights)
+        external{
+        require(_tokenVote.length == _weights.length);
+        _updateCurrentId();
+        deligateData memory deligate = deligations[_owner];
+        if(deligate.deligate == msg.sender && deligate.periods > 0  && deligate.canVoteForCurrentPeriod == true) {
+            _vote(_owner, _tokenVote, _weights);
+            if(deligate.periods > 2) {
+                deligate.periods -= 1;
+            }
+            if(deligate.periods == 2) {
+                deligate.periods = 0;
+            }
+        }
     }
 
     // Add new token gauge

From 9f99894c760fee0b5e49e45a4629c5d64ba94cfe Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 6 Apr 2022 17:29:48 +0530
Subject: [PATCH 11/55] fix: fixed deligation

---
 src/dill/gauge-proxy-v2.sol | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 8bf207772..fdd7038fe 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -851,20 +851,18 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     struct deligateData {
         address deligate;
-        uint256 periods;
+        int256 periods;
         bool canVoteForCurrentPeriod;
     }
     mapping (address => deligateData) public deligations;
-    // no. of periods 0 = none, 1 = indefinate , n = n-1 periods
+    // no. of periods 0 = none, <0 indefinate , >0 periods
 
-    function setVotingDelicate(address _delicate, uint256 _periodsCount) public {
+    function setVotingDelicate(address _delicate, int256 _periodsCount) public {
         require(_delicate != address(0), "GaugeProxyV2: cannot delicate zero address");
         require(_delicate != msg.sender, "GaugeProxyV2: delicating address cannot be delicated");
         deligations[msg.sender].deligate = _delicate;
         deligations[msg.sender].canVoteForCurrentPeriod = true;
-        if( _periodCount > 1) {
-            deligations[msg.sender].periods = _periodsCount + 1;
-        }
+        deligations[msg.sender].periods = _periodsCount;
     }
 
     function getActualCurrentPeriodId() public view returns (uint256) {
@@ -903,6 +901,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
             periods[i] = periods[i - 1];
         }
+        deligations[msg.sender].canVoteForCurrentPeriod = true;
     }
 
     // Reset votes to 0
@@ -1020,14 +1019,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(_tokenVote.length == _weights.length);
         _updateCurrentId();
         deligateData memory deligate = deligations[_owner];
-        if(deligate.deligate == msg.sender && deligate.periods > 0  && deligate.canVoteForCurrentPeriod == true) {
+        if(deligate.deligate == msg.sender && deligate.periods != 0  && deligate.canVoteForCurrentPeriod == true) {
             _vote(_owner, _tokenVote, _weights);
-            if(deligate.periods > 2) {
+            if(deligate.periods > 0) {
                 deligate.periods -= 1;
             }
-            if(deligate.periods == 2) {
-                deligate.periods = 0;
-            }
         }
     }
 

From 7f87274de2072b9b90ba19c4df2c4adf09dea8bf Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 7 Apr 2022 14:41:44 +0530
Subject: [PATCH 12/55] feat: updates to delegation

---
 src/dill/gauge-proxy-v2.sol | 60 +++++++++++++++++++++----------------
 1 file changed, 34 insertions(+), 26 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index fdd7038fe..ee8f9370f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -849,20 +849,28 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
     mapping(uint256 => periodData) public periods; // periodId => periodData
 
-    struct deligateData {
-        address deligate;
-        int256 periods;
-        bool canVoteForCurrentPeriod;
+    struct delegateData {
+        address delegate;
+        uint256 endPeriod;
+        mapping(uint256 => bool) blockDelegate; // Period => Boolean (if delegate address can vote in that period)
     }
-    mapping (address => deligateData) public deligations;
-    // no. of periods 0 = none, <0 indefinate , >0 periods
 
-    function setVotingDelicate(address _delicate, int256 _periodsCount) public {
-        require(_delicate != address(0), "GaugeProxyV2: cannot delicate zero address");
-        require(_delicate != msg.sender, "GaugeProxyV2: delicating address cannot be delicated");
-        deligations[msg.sender].deligate = _delicate;
-        deligations[msg.sender].canVoteForCurrentPeriod = true;
-        deligations[msg.sender].periods = _periodsCount;
+    mapping(address => delegateData) public delegations;
+
+    // no. of periods 0 = none, <0 indefinate , >0 periods
+    function setVotingDelegate(address _delegate, uint256 _periodsCount)
+        external
+    {
+        require(
+            _delegate != address(0),
+            "GaugeProxyV2: cannot delegate zero address"
+        );
+        require(
+            _delegate != msg.sender,
+            "GaugeProxyV2: delegate address cannot be delegating"
+        );
+        delegations[msg.sender].delegate = _delegate;
+        delegations[msg.sender].endPeriod = getActualCurrentPeriodId() + _periodsCount;
     }
 
     function getActualCurrentPeriodId() public view returns (uint256) {
@@ -901,7 +909,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
             periods[i] = periods[i - 1];
         }
-        deligations[msg.sender].canVoteForCurrentPeriod = true;
     }
 
     // Reset votes to 0
@@ -1011,20 +1018,22 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(_tokenVote.length == _weights.length);
         _updateCurrentId();
         _vote(msg.sender, _tokenVote, _weights);
-        deligations[msg.sender].canVoteForCurrentPeriod = false;
+        delegations[msg.sender].blockDelegate[currentId] = true;
     }
 
-    function voteFor(address _owner, address[] calldata _tokenVote, int256[] calldata _weights)
-        external{
+    function voteFor(
+        address _owner,
+        address[] calldata _tokenVote,
+        int256[] calldata _weights
+    ) external {
         require(_tokenVote.length == _weights.length);
         _updateCurrentId();
-        deligateData memory deligate = deligations[_owner];
-        if(deligate.deligate == msg.sender && deligate.periods != 0  && deligate.canVoteForCurrentPeriod == true) {
-            _vote(_owner, _tokenVote, _weights);
-            if(deligate.periods > 0) {
-                deligate.periods -= 1;
-            }
-        }
+        delegateData storage _delegate = delegations[_owner];
+        require(_delegate.delegate == msg.sender, "Sender not authorized");
+        require(_delegate.blockDelegate[currentId] == false, "Delegating address has already voted");
+        require(_delegate.endPeriod <= currentId, "Delegating period expired");
+        
+        _vote(_owner, _tokenVote, _weights);
     }
 
     // Add new token gauge
@@ -1054,9 +1063,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] storage newTokenArray;
         uint256 tokensLength = _tokens.length;
 
-        for (uint i = 0; i < tokensLength; i++){
-            if(_tokens[i] != _token)
-                newTokenArray.push(_tokens[i]);
+        for (uint256 i = 0; i < tokensLength; i++) {
+            if (_tokens[i] != _token) newTokenArray.push(_tokens[i]);
         }
 
         _tokens = newTokenArray;

From 5bfb06eb989c186a544bb63d83f548614adebde9 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 7 Apr 2022 15:57:27 +0530
Subject: [PATCH 13/55] feat: add indefinite delegation

---
 src/dill/gauge-proxy-v2.sol | 63 ++++++++++++++++++++++++++-----------
 1 file changed, 45 insertions(+), 18 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index ee8f9370f..fceb1f27c 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -831,36 +831,52 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public pid;
 
     address[] internal _tokens;
-    mapping(address => address) public gauges; // token => gauge
+    
+    // token => gauge
+    mapping(address => address) public gauges;
+
     mapping(address => uint256) public gaugeWithNegativeWeight;
 
     uint256 public constant week = 7 days;
     uint256 public constant weekSeconds = 604800;
-    uint256 public firstDistribution; // epoch time stamp
+    // epoch time stamp
+    uint256 public firstDistribution;
     uint256 public prevDistributionId;
     uint256 public currentId;
 
     struct periodData {
-        mapping(address => mapping(address => int256)) votes; // msg.sender => votes
-        mapping(address => int256) weights; // token => weight
-        mapping(address => address[]) tokenVote; // msg.sender => token
-        mapping(address => int256) usedWeights; // msg.sender => total voting weight of user
+        // msg.sender => votes
+        mapping(address => mapping(address => int256)) votes;
+        // token => weight
+        mapping(address => int256) weights;
+        // msg.sender => token
+        mapping(address => address[]) tokenVote;
+        // msg.sender => total voting weight of user
+        mapping(address => int256) usedWeights;
         int256 totalWeight;
     }
-    mapping(uint256 => periodData) public periods; // periodId => periodData
+
+    // periodId => periodData
+    mapping(uint256 => periodData) public periods;
 
     struct delegateData {
+        // delegated address
         address delegate;
+        // endPeriod if defined. Else 0.
         uint256 endPeriod;
-        mapping(uint256 => bool) blockDelegate; // Period => Boolean (if delegate address can vote in that period)
+        // If no endPeriod
+        bool indefinite;
+        // Period => Boolean (if delegate address can vote in that period)
+        mapping(uint256 => bool) blockDelegate;
     }
 
     mapping(address => delegateData) public delegations;
 
-    // no. of periods 0 = none, <0 indefinate , >0 periods
-    function setVotingDelegate(address _delegate, uint256 _periodsCount)
-        external
-    {
+    function setVotingDelegate(
+        address _delegate,
+        uint256 _periodsCount,
+        bool _indefinite
+    ) external {
         require(
             _delegate != address(0),
             "GaugeProxyV2: cannot delegate zero address"
@@ -870,7 +886,14 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "GaugeProxyV2: delegate address cannot be delegating"
         );
         delegations[msg.sender].delegate = _delegate;
-        delegations[msg.sender].endPeriod = getActualCurrentPeriodId() + _periodsCount;
+
+        if (_indefinite == true) {
+            delegations[msg.sender].indefinite = true;
+        } else {
+            delegations[msg.sender].endPeriod =
+                getActualCurrentPeriodId() +
+                _periodsCount;
+        }
     }
 
     function getActualCurrentPeriodId() public view returns (uint256) {
@@ -921,8 +944,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // Reset votes to 0
     function _reset(address _owner) internal {
         periodData storage _periodData = periods[currentId];
-
-        // lastVote[_owner] = 0;
         address[] storage _tokenVote = _periodData.tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
 
@@ -1030,9 +1051,15 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         _updateCurrentId();
         delegateData storage _delegate = delegations[_owner];
         require(_delegate.delegate == msg.sender, "Sender not authorized");
-        require(_delegate.blockDelegate[currentId] == false, "Delegating address has already voted");
-        require(_delegate.endPeriod <= currentId, "Delegating period expired");
-        
+        require(
+            _delegate.blockDelegate[currentId] == false,
+            "Delegating address has already voted"
+        );
+        require(
+            _delegate.indefinite == true || _delegate.endPeriod <= currentId,
+            "Delegating period expired"
+        );
+
         _vote(_owner, _tokenVote, _weights);
     }
 

From d8eab0605685d392ba89a68e2af937f788bc1a72 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 7 Apr 2022 16:40:07 +0530
Subject: [PATCH 14/55] feat: new delegate address can only vote after
 currentId

---
 src/dill/gauge-proxy-v2.sol | 68 +++++++++++++++++++++++--------------
 1 file changed, 42 insertions(+), 26 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index fceb1f27c..3c095c02c 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -831,7 +831,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public pid;
 
     address[] internal _tokens;
-    
+
     // token => gauge
     mapping(address => address) public gauges;
 
@@ -862,6 +862,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     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
@@ -872,30 +876,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     mapping(address => delegateData) public delegations;
 
-    function setVotingDelegate(
-        address _delegate,
-        uint256 _periodsCount,
-        bool _indefinite
-    ) external {
-        require(
-            _delegate != address(0),
-            "GaugeProxyV2: cannot delegate zero address"
-        );
-        require(
-            _delegate != msg.sender,
-            "GaugeProxyV2: delegate address cannot be delegating"
-        );
-        delegations[msg.sender].delegate = _delegate;
-
-        if (_indefinite == true) {
-            delegations[msg.sender].indefinite = true;
-        } else {
-            delegations[msg.sender].endPeriod =
-                getActualCurrentPeriodId() +
-                _periodsCount;
-        }
-    }
-
     function getActualCurrentPeriodId() public view returns (uint256) {
         uint256 lastPeriodEndTimestamp = (firstDistribution +
             (currentId * weekSeconds));
@@ -1042,6 +1022,36 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         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 actualCurrentPeriodId = getActualCurrentPeriodId();
+
+        address currentDelegate = _delegate.delegate;
+        _delegate.delegate = _delegateAddress;
+        _delegate.prevDelegate = currentDelegate;
+        _delegate.updatePeriodId = actualCurrentPeriodId;
+
+        if (_indefinite == true) {
+            _delegate.indefinite = true;
+        } else {
+            _delegate.endPeriod = actualCurrentPeriodId + _periodsCount;
+        }
+    }
+
     function voteFor(
         address _owner,
         address[] calldata _tokenVote,
@@ -1050,7 +1060,13 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(_tokenVote.length == _weights.length);
         _updateCurrentId();
         delegateData storage _delegate = delegations[_owner];
-        require(_delegate.delegate == msg.sender, "Sender not authorized");
+        require(
+            (_delegate.delegate == msg.sender &&
+                currentId > _delegate.updatePeriodId) ||
+                (_delegate.prevDelegate == msg.sender &&
+                    currentId == _delegate.updatePeriodId),
+            "Sender not authorized"
+        );
         require(
             _delegate.blockDelegate[currentId] == false,
             "Delegating address has already voted"

From 0bad1a2c543bb24854b065817c61f794b79e3092 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 13 Apr 2022 11:55:01 +0530
Subject: [PATCH 15/55] feat: upgraded to v 0.8.1

---
 src/dill/gauge-proxy-v2.sol | 326 ++++++++++--------------------------
 1 file changed, 88 insertions(+), 238 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 3c095c02c..842618a1e 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1,148 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.6.7; //^0.7.5;
-
-library SafeMath {
-    function add(uint256 a, uint256 b) internal pure returns (uint256) {
-        uint256 c = a + b;
-        require(c >= a, "add: +");
-
-        return c;
-    }
-
-    function add(
-        uint256 a,
-        uint256 b,
-        string memory errorMessage
-    ) internal pure returns (uint256) {
-        uint256 c = a + b;
-        require(c >= a, errorMessage);
-
-        return c;
-    }
-
-    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
-        return sub(a, b, "sub: -");
-    }
-
-    function sub(
-        uint256 a,
-        uint256 b,
-        string memory errorMessage
-    ) internal pure returns (uint256) {
-        require(b <= a, errorMessage);
-        uint256 c = a - b;
-
-        return c;
-    }
-
-    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
-        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
-        // benefit is lost if 'b' is also tested.
-        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
-        if (a == 0) {
-            return 0;
-        }
-
-        uint256 c = a * b;
-        require(c / a == b, "mul: *");
-
-        return c;
-    }
-
-    function mul(
-        uint256 a,
-        uint256 b,
-        string memory errorMessage
-    ) internal pure returns (uint256) {
-        if (a == 0) {
-            return 0;
-        }
-
-        uint256 c = a * b;
-        require(c / a == b, errorMessage);
-
-        return c;
-    }
-
-    function div(uint256 a, uint256 b) internal pure returns (uint256) {
-        return div(a, b, "div: /");
-    }
-
-    function div(
-        uint256 a,
-        uint256 b,
-        string memory errorMessage
-    ) internal pure returns (uint256) {
-        require(b > 0, errorMessage);
-        uint256 c = a / b;
-
-        return c;
-    }
-}
-
-/**
- * @dev Wrappers over Solidity's arithmetic operations.
- *
- * NOTE: `SignedSafeMath` is no longer needed starting with Solidity 0.8. The compiler
- * now has built in overflow checking.
- */
-library SignedSafeMath {
-    /**
-     * @dev Returns the multiplication of two signed integers, reverting on
-     * overflow.
-     *
-     * Counterpart to Solidity's `*` operator.
-     *
-     * Requirements:
-     *
-     * - Multiplication cannot overflow.
-     */
-    function mul(int256 a, int256 b) internal pure returns (int256) {
-        return a * b;
-    }
-
-    /**
-     * @dev Returns the integer division of two signed integers. Reverts on
-     * division by zero. The result is rounded towards zero.
-     *
-     * Counterpart to Solidity's `/` operator.
-     *
-     * Requirements:
-     *
-     * - The divisor cannot be zero.
-     */
-    function div(int256 a, int256 b) internal pure returns (int256) {
-        return a / b;
-    }
-
-    /**
-     * @dev Returns the subtraction of two signed integers, reverting on
-     * overflow.
-     *
-     * Counterpart to Solidity's `-` operator.
-     *
-     * Requirements:
-     *
-     * - Subtraction cannot overflow.
-     */
-    function sub(int256 a, int256 b) internal pure returns (int256) {
-        return a - b;
-    }
-
-    /**
-     * @dev Returns the addition of two signed integers, reverting on
-     * overflow.
-     *
-     * Counterpart to Solidity's `+` operator.
-     *
-     * Requirements:
-     *
-     * - Addition cannot overflow.
-     */
-    function add(int256 a, int256 b) internal pure returns (int256) {
-        return a + b;
-    }
-}
+pragma solidity ^0.8.1; // ^0.6.7; //^0.7.5;
 
 library Address {
     function isContract(address account) internal view returns (bool) {
@@ -160,7 +17,9 @@ library Address {
         pure
         returns (address payable)
     {
-        return address(uint160(account));
+        // return address(uint160(account));
+        return payable(address(uint160(account)));
+
     }
 
     function sendValue(address payable recipient, uint256 amount) internal {
@@ -202,7 +61,7 @@ interface IERC20 {
 }
 
 library SafeERC20 {
-    using SafeMath for uint256;
+    
     using Address for address;
 
     function safeTransfer(
@@ -248,7 +107,7 @@ library SafeERC20 {
         address spender,
         uint256 value
     ) internal {
-        uint256 newAllowance = token.allowance(address(this), spender).add(
+        uint256 newAllowance = token.allowance(address(this), spender) + (
             value
         );
         callOptionalReturn(
@@ -266,9 +125,10 @@ library SafeERC20 {
         address spender,
         uint256 value
     ) internal {
-        uint256 newAllowance = token.allowance(address(this), spender).sub(
-            value,
-            "SafeERC20: decreased allowance below zero"
+        uint256 newAllowance = token.allowance(address(this), spender) - (
+            value
+            // ,
+            // "SafeERC20: decreased allowance below zero"
         );
         callOptionalReturn(
             token,
@@ -356,7 +216,8 @@ abstract contract ReentrancyGuard {
 
     uint256 private _status;
 
-    constructor() public {
+    // constructor() public {
+        constructor() {
         _status = _NOT_ENTERED;
     }
 
@@ -383,7 +244,7 @@ abstract contract ReentrancyGuard {
 }
 
 contract Gauge is ReentrancyGuard {
-    using SafeMath for uint256;
+    
     using SafeERC20 for IERC20;
 
     IERC20 public constant PICKLE =
@@ -441,42 +302,42 @@ contract Gauge is ReentrancyGuard {
             return rewardPerTokenStored;
         }
         return
-            rewardPerTokenStored.add(
-                lastTimeRewardApplicable()
-                    .sub(lastUpdateTime)
-                    .mul(rewardRate)
-                    .mul(1e18)
-                    .div(derivedSupply)
+            rewardPerTokenStored + (
+                ((lastTimeRewardApplicable()
+                    - (lastUpdateTime))
+                    * (rewardRate)
+                    * (1e18))
+                    / (derivedSupply)
             );
     }
 
     function derivedBalance(address account) public view returns (uint256) {
         uint256 _balance = _balances[account];
-        uint256 _derived = _balance.mul(40).div(100);
+        uint256 _derived = _balance * (40) / (100);
         uint256 _adjusted = (
-            _totalSupply.mul(DILL.balanceOf(account)).div(DILL.totalSupply())
-        ).mul(60).div(100);
-        return Math.min(_derived.add(_adjusted), _balance);
+            _totalSupply * (DILL.balanceOf(account)) / (DILL.totalSupply())
+        ) * (60) / (100);
+        return Math.min(_derived + (_adjusted), _balance);
     }
 
     function kick(address account) public {
         uint256 _derivedBalance = derivedBalances[account];
-        derivedSupply = derivedSupply.sub(_derivedBalance);
+        derivedSupply -= (_derivedBalance);
         _derivedBalance = derivedBalance(account);
         derivedBalances[account] = _derivedBalance;
-        derivedSupply = derivedSupply.add(_derivedBalance);
+        derivedSupply += (_derivedBalance);
     }
 
     function earned(address account) public view returns (uint256) {
         return
-            derivedBalances[account]
-                .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
-                .div(1e18)
-                .add(rewards[account]);
+            (derivedBalances[account]
+                * (rewardPerToken() - (userRewardPerTokenPaid[account]))
+                / (1e18))
+                + (rewards[account]);
     }
 
     function getRewardForDuration() external view returns (uint256) {
-        return rewardRate.mul(DURATION);
+        return rewardRate * (DURATION);
     }
 
     function depositAll() external {
@@ -497,8 +358,8 @@ contract Gauge is ReentrancyGuard {
         updateReward(account)
     {
         require(amount > 0, "Cannot stake 0");
-        _totalSupply = _totalSupply.add(amount);
-        _balances[account] = _balances[account].add(amount);
+        _totalSupply += (amount);
+        _balances[account] += (amount);
         emit Staked(account, amount);
         TOKEN.safeTransferFrom(account, address(this), amount);
     }
@@ -517,8 +378,8 @@ contract Gauge is ReentrancyGuard {
         updateReward(msg.sender)
     {
         require(amount > 0, "Cannot withdraw 0");
-        _totalSupply = _totalSupply.sub(amount);
-        _balances[msg.sender] = _balances[msg.sender].sub(amount);
+        _totalSupply -= (amount);
+        _balances[msg.sender] -= (amount);
         TOKEN.safeTransfer(msg.sender, amount);
         emit Withdrawn(msg.sender, amount);
     }
@@ -544,11 +405,11 @@ contract Gauge is ReentrancyGuard {
     {
         PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
         if (block.timestamp >= periodFinish) {
-            rewardRate = reward.div(DURATION);
+            rewardRate = reward / (DURATION);
         } else {
-            uint256 remaining = periodFinish.sub(block.timestamp);
-            uint256 leftover = remaining.mul(rewardRate);
-            rewardRate = reward.add(leftover).div(DURATION);
+            uint256 remaining = periodFinish - (block.timestamp);
+            uint256 leftover = remaining * (rewardRate);
+            rewardRate = (reward + leftover) / DURATION;
         }
 
         // Ensure the provided reward amount is not more than the balance in the contract.
@@ -557,12 +418,12 @@ contract Gauge is ReentrancyGuard {
         // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
         uint256 balance = PICKLE.balanceOf(address(this));
         require(
-            rewardRate <= balance.div(DURATION),
+            rewardRate <= balance / (DURATION),
             "Provided reward too high"
         );
 
         lastUpdateTime = block.timestamp;
-        periodFinish = block.timestamp.add(DURATION);
+        periodFinish = block.timestamp + DURATION;
         emit RewardAdded(reward);
     }
 
@@ -623,7 +484,7 @@ contract ProtocolGovernance {
 }
 
 contract MasterDill {
-    using SafeMath for uint256;
+    
 
     /// @notice EIP-20 token name for this token
     string public constant name = "Master DILL";
@@ -719,10 +580,12 @@ contract MasterDill {
         address spender = msg.sender;
         uint256 spenderAllowance = allowances[src][spender];
 
-        if (spender != src && spenderAllowance != uint256(-1)) {
-            uint256 newAllowance = spenderAllowance.sub(
-                amount,
-                "transferFrom: exceeds spender allowance"
+        // if (spender != src && spenderAllowance != uint256(-1)) { // type(uint256).max
+        if (spender != src && spenderAllowance != type(uint256).max) {
+            uint256 newAllowance = spenderAllowance - (
+                amount
+                // ,
+                // "transferFrom: exceeds spender allowance"
             );
             allowances[src][spender] = newAllowance;
 
@@ -741,11 +604,15 @@ contract MasterDill {
         require(src != address(0), "_transferTokens: zero address");
         require(dst != address(0), "_transferTokens: zero address");
 
-        balances[src] = balances[src].sub(
-            amount,
-            "_transferTokens: exceeds balance"
+        balances[src] = balances[src] - (
+            amount
+            // ,
+            // "_transferTokens: exceeds balance"
         );
-        balances[dst] = balances[dst].add(amount, "_transferTokens: overflows");
+        balances[dst] += (amount
+        // ,
+        //  "_transferTokens: overflows"
+         );
         emit Transfer(src, dst, amount);
     }
 }
@@ -815,8 +682,7 @@ contract Initializable {
 }
 
 contract GaugeProxyV2 is ProtocolGovernance, Initializable {
-    using SafeMath for uint256;
-    using SignedSafeMath for int256;
+    
     using SafeERC20 for IERC20;
 
     MasterChef public constant MASTER =
@@ -843,21 +709,13 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public firstDistribution;
     uint256 public prevDistributionId;
     uint256 public currentId;
+    address[] internal _tokensTemp;
 
-    struct periodData {
-        // msg.sender => votes
-        mapping(address => mapping(address => int256)) votes;
-        // token => weight
-        mapping(address => int256) weights;
-        // msg.sender => token
-        mapping(address => address[]) tokenVote;
-        // msg.sender => total voting weight of user
-        mapping(address => int256) usedWeights;
-        int256 totalWeight;
-    }
-
-    // periodId => periodData
-    mapping(uint256 => periodData) public periods;
+    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(address => int256[]) public weights; // token => weight [period id]
+    int256[] public totalWeight; // [period id]
 
     struct delegateData {
         // delegated address
@@ -902,7 +760,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
         firstDistribution = _firstDistribution;
-        currentId = 1;
+        currentId = 0; //1;
         prevDistributionId = 0;
     }
 
@@ -910,7 +768,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         uint256 prevPeriodId = currentId;
         currentId = getActualCurrentPeriodId();
         for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
-            periods[i] = periods[i - 1];
+            totalWeight[i] = totalWeight[i-1];
         }
     }
 
@@ -923,44 +781,40 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Reset votes to 0
     function _reset(address _owner) internal {
-        periodData storage _periodData = periods[currentId];
-        address[] storage _tokenVote = _periodData.tokenVote[_owner];
+        address[] storage _tokenVote = tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
-
         for (uint256 i = 0; i < _tokenVoteCnt; i++) {
             address _token = _tokenVote[i];
-            int256 _votes = _periodData.votes[_owner][_token];
+            int256 _votes = votes[_owner][_token];
 
             if (_votes != 0) {
-                _periodData.totalWeight = _periodData.totalWeight.sub(
+                totalWeight[currentId] -= (
                     _votes > 0 ? _votes : -_votes
                 );
-                _periodData.weights[_token] = _periodData.weights[_token].sub(
+                weights[_token][currentId] -= (
                     _votes
                 );
 
-                _periodData.votes[_owner][_token] = 0;
+                votes[_owner][_token] = 0;
             }
         }
 
-        delete _periodData.tokenVote[_owner];
+        delete tokenVote[_owner];
     }
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
     function poke(address _owner) public {
         _updateCurrentId();
-        periodData storage _periodData = periods[currentId];
-
-        address[] memory _tokenVote = _periodData.tokenVote[_owner];
+        address[] memory _tokenVote = tokenVote[_owner];
         uint256 _tokenCnt = _tokenVote.length;
         int256[] memory _weights = new int256[](_tokenCnt);
 
-        int256 _prevUsedWeight = _periodData.usedWeights[_owner];
+        int256 _prevUsedWeight = usedWeights[_owner];
         int256 _weight = int256(DILL.balanceOf(_owner));
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            int256 _prevWeight = _periodData.votes[_owner][_tokenVote[i]];
-            _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
+            int256 _prevWeight = votes[_owner][_tokenVote[i]];
+            _weights[i] = _prevWeight * (_weight) / (_prevUsedWeight);
         }
         _vote(_owner, _tokenVote, _weights);
     }
@@ -977,39 +831,37 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         int256 _usedWeight = 0;
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            _totalVoteWeight = _totalVoteWeight.add(
+            _totalVoteWeight += (
                 _weights[i] > 0 ? _weights[i] : -_weights[i]
             );
         }
 
-        periodData storage _periodData = periods[currentId];
-
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
-            int256 _tokenWeight = _weights[i].mul(_weight).div(
+            int256 _tokenWeight = _weights[i] * (_weight) / (
                 _totalVoteWeight
             );
-
+            weights[_token][currentId] = weights[_token][currentId - 1];
             if (_gauge != address(0x0)) {
-                _periodData.weights[_token] = _periodData.weights[_token].add(
+                weights[_token][currentId] += (
                     _tokenWeight
                 );
-                _periodData.votes[_owner][_token] = _tokenWeight;
-                _periodData.tokenVote[_owner].push(_token);
+                votes[_owner][_token] = _tokenWeight;
+                tokenVote[_owner].push(_token);
 
                 if (_tokenWeight < 0) {
                     _tokenWeight = -_tokenWeight;
                 }
 
-                _usedWeight = _usedWeight.add(_tokenWeight);
-                _periodData.totalWeight = _periodData.totalWeight.add(
+                _usedWeight += (_tokenWeight);
+                totalWeight[currentId] += (
                     _tokenWeight
                 );
             }
         }
 
-        _periodData.usedWeights[_owner] = _usedWeight;
+        usedWeights[_owner] = _usedWeight;
     }
 
     // Vote with DILL on a gauge
@@ -1103,14 +955,13 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         delete gauges[_token];
 
-        address[] storage newTokenArray;
+        // address[] storage newTokenArray = new address[]();
         uint256 tokensLength = _tokens.length;
 
         for (uint256 i = 0; i < tokensLength; i++) {
-            if (_tokens[i] != _token) newTokenArray.push(_tokens[i]);
+            if (_tokens[i] != _token) _tokensTemp.push(_tokens[i]);
         }
-
-        _tokens = newTokenArray;
+        _tokens = _tokensTemp;
     }
 
     // Sets MasterChef PID
@@ -1159,14 +1010,13 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         collect();
         int256 _balance = int256(PICKLE.balanceOf(address(this)));
-        periodData storage _periodData = periods[prevDistributionId + 1];
-        int256 _totalWeight = _periodData.totalWeight;
+        int256 _totalWeight = totalWeight[prevDistributionId + 1];
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
                 uint256 _reward = uint256(
-                    _balance.mul(_periodData.weights[_token]).div(_totalWeight)
+                    _balance * (weights[_token][prevDistributionId + 1]) / (_totalWeight)
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);

From 717caa227e871b7f781165f55b36968c617733cc Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 21 Apr 2022 20:16:42 +0530
Subject: [PATCH 16/55] WIP: gaugeProxyV2 tests

---
 .../dill-test/5.vote-and-distribute-v2.js     | 117 ++++++++++++++++++
 src/dill/gauge-proxy-v2.sol                   |   6 +-
 2 files changed, 120 insertions(+), 3 deletions(-)
 create mode 100644 hardhat-scripts/dill-test/5.vote-and-distribute-v2.js

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..a397385ba
--- /dev/null
+++ b/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
@@ -0,0 +1,117 @@
+// 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],
+  });
+  console.log("impersonation gov");
+  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);
+
+  console.log("-- Deploying GaugeProxy v2 contract --");
+  const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2");
+  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);
+
+  console.log("-- Voting on LP Gauge with 100% weight --");
+
+  await hre.network.provider.request({
+    method: "evm_unlockUnknownAccount",
+    params: [userAddr],
+  });
+  console.log("impersonating user");
+  const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+  populatedTx = await gaugeProxyFromUser.populateTransaction.vote([pickleLP, pyveCRVETH], [6000000, 4000000], {
+    gasLimit: 900000,
+  });
+  await userSigner.sendTransaction(populatedTx);
+  console.log("voted");
+  const pidDill = (await masterChef.poolLength()) - 1;
+  await GaugeProxyV2.setPID(pidDill);
+  await GaugeProxyV2.deposit();
+
+  console.log("-- Wait for 10 blocks to be mined --");
+  for (let i = 0; i < 10; i++) {
+    await hre.network.provider.request({
+      method: "evm_mine",
+    });
+  }
+  console.log("-- Wait 7 days to accumulate");
+  await hre.network.provider.request({
+    method: "evm_increaseTime",
+    params: [3600 * 24 * 7],
+  });
+  await hre.network.provider.request({
+    method: "evm_mine",
+  });
+
+  await hre.network.provider.request({
+    method: "evm_unlockUnknownAccount",
+    params: [governanceAddr],
+  });
+
+  console.log("-- Distribute PICKLE to gauges --");
+  await GaugeProxyV2.distribute(0,1);
+
+  const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+  const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+  // const pickle = await ethers.getContractAt("PickleToken", pickleAddr);
+  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);
+
+  const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+  console.log("rewards to pyveCRV gauge", yvecrvRewards);
+}
+
+// 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-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 842618a1e..cb9f56e6d 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -867,8 +867,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // Vote with DILL on a gauge
     function vote(address[] calldata _tokenVote, int256[] calldata _weights)
         external
-    {
-        require(_tokenVote.length == _weights.length);
+    {   
+        require(_tokenVote.length == _weights.length, "GaugeProxy: token votes count does not match weights count");
         _updateCurrentId();
         _vote(msg.sender, _tokenVote, _weights);
         delegations[msg.sender].blockDelegate[currentId] = true;
@@ -909,7 +909,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] calldata _tokenVote,
         int256[] calldata _weights
     ) external {
-        require(_tokenVote.length == _weights.length);
+        require(_tokenVote.length == _weights.length,"GaugeProxy: token votes count does not match weights count");
         _updateCurrentId();
         delegateData storage _delegate = delegations[_owner];
         require(

From e1cbec31f0e0af65c64331f3d3768273cbae63c5 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 26 Apr 2022 18:52:26 +0530
Subject: [PATCH 17/55] WIP: periodisation test

---
 .../dill-test/5.vote-and-distribute-v2.js     |  65 ++++---
 src/dill/gauge-proxy-v2.sol                   | 177 +++++++++---------
 2 files changed, 134 insertions(+), 108 deletions(-)

diff --git a/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js b/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
index a397385ba..17234c8cf 100644
--- a/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
+++ b/hardhat-scripts/dill-test/5.vote-and-distribute-v2.js
@@ -20,7 +20,7 @@ async function main() {
     method: "evm_unlockUnknownAccount",
     params: [governanceAddr],
   });
-  console.log("impersonation gov");
+
   const governanceSigner = ethers.provider.getSigner(governanceAddr);
   const userSigner = ethers.provider.getSigner(userAddr);
   const masterChef = await ethers.getContractAt(
@@ -30,10 +30,19 @@ async function main() {
   );
   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");
+  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()], {
+  const GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
     initializer: "initialize",
   });
   await GaugeProxyV2.deployed();
@@ -50,22 +59,29 @@ async function main() {
   );
   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);
 
-  console.log("-- Voting on LP Gauge with 100% weight --");
-
   await hre.network.provider.request({
     method: "evm_unlockUnknownAccount",
     params: [userAddr],
   });
-  console.log("impersonating user");
+  // 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: 900000,
+    gasLimit: 9000000,
   });
   await userSigner.sendTransaction(populatedTx);
   console.log("voted");
@@ -73,38 +89,39 @@ async function main() {
   await GaugeProxyV2.setPID(pidDill);
   await GaugeProxyV2.deposit();
 
-  console.log("-- Wait for 10 blocks to be mined --");
-  for (let i = 0; i < 10; i++) {
-    await hre.network.provider.request({
-      method: "evm_mine",
-    });
-  }
+  /** ************************************* increase time by 7 days ****************************************** */
   console.log("-- Wait 7 days to accumulate");
   await hre.network.provider.request({
     method: "evm_increaseTime",
     params: [3600 * 24 * 7],
   });
-  await hre.network.provider.request({
-    method: "evm_mine",
-  });
 
+  /** ************************************* mine block ****************************************** */
+  console.log("-- Wait for 1 block to be mined --");
   await hre.network.provider.request({
-    method: "evm_unlockUnknownAccount",
-    params: [governanceAddr],
+    method: "evm_mine",
   });
 
+  /** ************************************* DISTRIBUTE ****************************************** */
+  await GaugeProxyV2.updateCurrentId();
+  console.log("currentId", (await GaugeProxyV2.currentId()).toString());
   console.log("-- Distribute PICKLE to gauges --");
-  await GaugeProxyV2.distribute(0,1);
+  await GaugeProxyV2.distribute(0, 2);
+
+  /** ************************************* get gauge address ****************************************** */
 
   const pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
   const yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
-  // const pickle = await ethers.getContractAt("PickleToken", pickleAddr);
+
+  /** *************************************get PICKLE contract ****************************************** */
   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);
 
-  const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
-  console.log("rewards to pyveCRV gauge", yvecrvRewards);
+  /** *************************************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
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index cb9f56e6d..25e3b2d82 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -19,7 +19,6 @@ library Address {
     {
         // return address(uint160(account));
         return payable(address(uint160(account)));
-
     }
 
     function sendValue(address payable recipient, uint256 amount) internal {
@@ -61,7 +60,6 @@ interface IERC20 {
 }
 
 library SafeERC20 {
-    
     using Address for address;
 
     function safeTransfer(
@@ -107,9 +105,8 @@ library SafeERC20 {
         address spender,
         uint256 value
     ) internal {
-        uint256 newAllowance = token.allowance(address(this), spender) + (
-            value
-        );
+        uint256 newAllowance = token.allowance(address(this), spender) +
+            (value);
         callOptionalReturn(
             token,
             abi.encodeWithSelector(
@@ -125,11 +122,12 @@ library SafeERC20 {
         address spender,
         uint256 value
     ) internal {
-        uint256 newAllowance = token.allowance(address(this), spender) - (
-            value
-            // ,
-            // "SafeERC20: decreased allowance below zero"
-        );
+        uint256 newAllowance = token.allowance(address(this), spender) -
+            (
+                value
+                // ,
+                // "SafeERC20: decreased allowance below zero"
+            );
         callOptionalReturn(
             token,
             abi.encodeWithSelector(
@@ -217,7 +215,7 @@ abstract contract ReentrancyGuard {
     uint256 private _status;
 
     // constructor() public {
-        constructor() {
+    constructor() {
         _status = _NOT_ENTERED;
     }
 
@@ -244,7 +242,6 @@ abstract contract ReentrancyGuard {
 }
 
 contract Gauge is ReentrancyGuard {
-    
     using SafeERC20 for IERC20;
 
     IERC20 public constant PICKLE =
@@ -302,21 +299,17 @@ contract Gauge is ReentrancyGuard {
             return rewardPerTokenStored;
         }
         return
-            rewardPerTokenStored + (
-                ((lastTimeRewardApplicable()
-                    - (lastUpdateTime))
-                    * (rewardRate)
-                    * (1e18))
-                    / (derivedSupply)
-            );
+            rewardPerTokenStored +
+            (((lastTimeRewardApplicable() - (lastUpdateTime)) *
+                (rewardRate) *
+                (1e18)) / (derivedSupply));
     }
 
     function derivedBalance(address account) public view returns (uint256) {
         uint256 _balance = _balances[account];
-        uint256 _derived = _balance * (40) / (100);
-        uint256 _adjusted = (
-            _totalSupply * (DILL.balanceOf(account)) / (DILL.totalSupply())
-        ) * (60) / (100);
+        uint256 _derived = (_balance * (40)) / (100);
+        uint256 _adjusted = (((_totalSupply * (DILL.balanceOf(account))) /
+            (DILL.totalSupply())) * (60)) / (100);
         return Math.min(_derived + (_adjusted), _balance);
     }
 
@@ -330,10 +323,9 @@ contract Gauge is ReentrancyGuard {
 
     function earned(address account) public view returns (uint256) {
         return
-            (derivedBalances[account]
-                * (rewardPerToken() - (userRewardPerTokenPaid[account]))
-                / (1e18))
-                + (rewards[account]);
+            ((derivedBalances[account] *
+                (rewardPerToken() - (userRewardPerTokenPaid[account]))) /
+                (1e18)) + (rewards[account]);
     }
 
     function getRewardForDuration() external view returns (uint256) {
@@ -417,10 +409,7 @@ contract Gauge is ReentrancyGuard {
         // 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 = PICKLE.balanceOf(address(this));
-        require(
-            rewardRate <= balance / (DURATION),
-            "Provided reward too high"
-        );
+        require(rewardRate <= balance / (DURATION), "Provided reward too high");
 
         lastUpdateTime = block.timestamp;
         periodFinish = block.timestamp + DURATION;
@@ -484,8 +473,6 @@ contract ProtocolGovernance {
 }
 
 contract MasterDill {
-    
-
     /// @notice EIP-20 token name for this token
     string public constant name = "Master DILL";
 
@@ -582,11 +569,12 @@ contract MasterDill {
 
         // if (spender != src && spenderAllowance != uint256(-1)) { // type(uint256).max
         if (spender != src && spenderAllowance != type(uint256).max) {
-            uint256 newAllowance = spenderAllowance - (
-                amount
-                // ,
-                // "transferFrom: exceeds spender allowance"
-            );
+            uint256 newAllowance = spenderAllowance -
+                (
+                    amount
+                    // ,
+                    // "transferFrom: exceeds spender allowance"
+                );
             allowances[src][spender] = newAllowance;
 
             emit Approval(src, spender, newAllowance);
@@ -604,15 +592,18 @@ contract MasterDill {
         require(src != address(0), "_transferTokens: zero address");
         require(dst != address(0), "_transferTokens: zero address");
 
-        balances[src] = balances[src] - (
+        balances[src] =
+            balances[src] -
+            (
+                amount
+                // ,
+                // "_transferTokens: exceeds balance"
+            );
+        balances[dst] += (
             amount
             // ,
-            // "_transferTokens: exceeds balance"
+            //  "_transferTokens: overflows"
         );
-        balances[dst] += (amount
-        // ,
-        //  "_transferTokens: overflows"
-         );
         emit Transfer(src, dst, amount);
     }
 }
@@ -682,7 +673,6 @@ contract Initializable {
 }
 
 contract GaugeProxyV2 is ProtocolGovernance, Initializable {
-    
     using SafeERC20 for IERC20;
 
     MasterChef public constant MASTER =
@@ -707,8 +697,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public constant weekSeconds = 604800;
     // epoch time stamp
     uint256 public firstDistribution;
-    uint256 public prevDistributionId;
+    uint256 public distributionId;
     uint256 public currentId;
+    address public _sender;
     address[] internal _tokensTemp;
 
     mapping(address => int256) public usedWeights; // msg.sender => total voting weight of user
@@ -737,15 +728,16 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function getActualCurrentPeriodId() public view returns (uint256) {
         uint256 lastPeriodEndTimestamp = (firstDistribution +
             (currentId * weekSeconds));
-        if (lastPeriodEndTimestamp < block.timestamp) {
+        if (lastPeriodEndTimestamp + weekSeconds < block.timestamp) {
             uint256 weeksElapsed = (block.timestamp - lastPeriodEndTimestamp) /
                 60 /
                 60 /
                 24 /
                 7;
 
-            return currentId + weeksElapsed + 1;
+            return currentId + weeksElapsed ;
         }
+        return currentId;
     }
 
     function tokens() external view returns (address[] memory) {
@@ -760,15 +752,21 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
         firstDistribution = _firstDistribution;
-        currentId = 0; //1;
-        prevDistributionId = 0;
+        currentId = 0;
+        distributionId = 0;
+    }
+    function updateCurrentId() public {
+        _updateCurrentId();
     }
-
     function _updateCurrentId() internal {
         uint256 prevPeriodId = currentId;
         currentId = getActualCurrentPeriodId();
-        for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
-            totalWeight[i] = totalWeight[i-1];
+        if (currentId == 0) {
+            totalWeight.push(0);
+        } else {
+            for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
+                totalWeight.push(totalWeight[i - 1]);
+            }
         }
     }
 
@@ -788,12 +786,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             int256 _votes = votes[_owner][_token];
 
             if (_votes != 0) {
-                totalWeight[currentId] -= (
-                    _votes > 0 ? _votes : -_votes
-                );
-                weights[_token][currentId] -= (
-                    _votes
-                );
+                totalWeight[currentId] -= (_votes > 0 ? _votes : -_votes);
+                weights[_token][currentId] -= (_votes);
 
                 votes[_owner][_token] = 0;
             }
@@ -814,7 +808,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
             int256 _prevWeight = votes[_owner][_tokenVote[i]];
-            _weights[i] = _prevWeight * (_weight) / (_prevUsedWeight);
+            _weights[i] = (_prevWeight * (_weight)) / (_prevUsedWeight);
         }
         _vote(_owner, _tokenVote, _weights);
     }
@@ -831,22 +825,20 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         int256 _usedWeight = 0;
 
         for (uint256 i = 0; i < _tokenCnt; i++) {
-            _totalVoteWeight += (
-                _weights[i] > 0 ? _weights[i] : -_weights[i]
-            );
+            _totalVoteWeight += (_weights[i] > 0 ? _weights[i] : -_weights[i]);
         }
-
+        // uint256 i = 0;
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
-            int256 _tokenWeight = _weights[i] * (_weight) / (
-                _totalVoteWeight
-            );
-            weights[_token][currentId] = weights[_token][currentId - 1];
+            int256 _tokenWeight = (_weights[i] * _weight) / _totalVoteWeight;
+            if (currentId == 0) {
+                weights[_token].push(0);
+            } else {
+                weights[_token].push(weights[_token][currentId - 1]);
+            }
             if (_gauge != address(0x0)) {
-                weights[_token][currentId] += (
-                    _tokenWeight
-                );
+                weights[_token][currentId] += _tokenWeight;
                 votes[_owner][_token] = _tokenWeight;
                 tokenVote[_owner].push(_token);
 
@@ -854,10 +846,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                     _tokenWeight = -_tokenWeight;
                 }
 
-                _usedWeight += (_tokenWeight);
-                totalWeight[currentId] += (
-                    _tokenWeight
-                );
+                _usedWeight += _tokenWeight;
+                // totalWeight.push(0);
+                totalWeight[currentId] += _tokenWeight;
             }
         }
 
@@ -867,8 +858,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // 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");
+    {
+        require(
+            _tokenVote.length == _weights.length,
+            "GaugeProxy: token votes count does not match weights count"
+        );
         _updateCurrentId();
         _vote(msg.sender, _tokenVote, _weights);
         delegations[msg.sender].blockDelegate[currentId] = true;
@@ -909,7 +903,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] calldata _tokenVote,
         int256[] calldata _weights
     ) external {
-        require(_tokenVote.length == _weights.length,"GaugeProxy: token votes count does not match weights count");
+        require(
+            _tokenVote.length == _weights.length,
+            "GaugeProxy: token votes count does not match weights count"
+        );
         _updateCurrentId();
         delegateData storage _delegate = delegations[_owner];
         require(
@@ -945,7 +942,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         uint256 _actualCurrentId = getActualCurrentPeriodId();
         require(
-            prevDistributionId == _actualCurrentId - 1,
+            distributionId == _actualCurrentId - 1,
             "! all distributions completed"
         );
 
@@ -1000,23 +997,35 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             msg.sender == governance,
             "GaugeProxyV2: only governance can distribute"
         );
+        _sender = msg.sender;
 
         _updateCurrentId();
-
+        require(currentId > 0, "initial voting in progress");
         require(
-            prevDistributionId < currentId - 1,
+            // currentId == 0 ?
+            // distributionId == 0 :
+            distributionId < currentId,
             "GaugeProxyV2: all period distributions complete"
         );
 
         collect();
         int256 _balance = int256(PICKLE.balanceOf(address(this)));
-        int256 _totalWeight = totalWeight[prevDistributionId + 1];
+        // int256 _totalWeight = currentId == 0
+        //     ? totalWeight[distributionId]
+        //     : totalWeight[distributionId + 1];
+        int256 _totalWeight =  totalWeight[distributionId];
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
                 uint256 _reward = uint256(
-                    _balance * (weights[_token][prevDistributionId + 1]) / (_totalWeight)
+                    (_balance *
+                        (
+                            weights[_token][distributionId]
+                            // currentId == 0
+                            //     ? weights[_token][distributionId]
+                            //     : weights[_token][distributionId + 1]
+                        )) / (_totalWeight)
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
@@ -1031,7 +1040,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         if (_tokens.length == _end) {
-            prevDistributionId += 1;
+            distributionId += 1;
         }
     }
 }

From 1fe8a99ad2a6e565ac2922b5b233b71a924c5261 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 27 Apr 2022 19:13:19 +0530
Subject: [PATCH 18/55] feat: refactored logic to remove arrays

---
 src/dill/gauge-proxy-v2.sol | 160 ++++++++++++++++++------------------
 1 file changed, 78 insertions(+), 82 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 25e3b2d82..113c35583 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -693,20 +693,19 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     mapping(address => uint256) public gaugeWithNegativeWeight;
 
-    uint256 public constant week = 7 days;
-    uint256 public constant weekSeconds = 604800;
+    uint256 public constant WEEK_SECONDS = 604800;
     // epoch time stamp
     uint256 public firstDistribution;
     uint256 public distributionId;
-    uint256 public currentId;
+    uint256 public lastVotedPeriodId;
     address public _sender;
-    address[] internal _tokensTemp;
 
+    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(address => int256[]) public weights; // token => weight [period id]
-    int256[] public totalWeight; // [period id]
+    mapping(uint256 => mapping(address => int256)) public weights; // period id => token => weight
+    mapping(uint256 => int256) public totalWeight; // period id => TotalWeight
 
     struct delegateData {
         // delegated address
@@ -725,19 +724,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     mapping(address => delegateData) public delegations;
 
-    function getActualCurrentPeriodId() public view returns (uint256) {
-        uint256 lastPeriodEndTimestamp = (firstDistribution +
-            (currentId * weekSeconds));
-        if (lastPeriodEndTimestamp + weekSeconds < block.timestamp) {
-            uint256 weeksElapsed = (block.timestamp - lastPeriodEndTimestamp) /
-                60 /
-                60 /
-                24 /
-                7;
-
-            return currentId + weeksElapsed ;
-        }
-        return currentId;
+    function getCurrentPeriodId() public view returns (uint256) {
+        return
+            block.timestamp > firstDistribution
+                ? block.timestamp - firstDistribution / WEEK_SECONDS
+                : 0;
     }
 
     function tokens() external view returns (address[] memory) {
@@ -752,28 +743,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
         firstDistribution = _firstDistribution;
-        currentId = 0;
         distributionId = 0;
-    }
-    function updateCurrentId() public {
-        _updateCurrentId();
-    }
-    function _updateCurrentId() internal {
-        uint256 prevPeriodId = currentId;
-        currentId = getActualCurrentPeriodId();
-        if (currentId == 0) {
-            totalWeight.push(0);
-        } else {
-            for (uint256 i = prevPeriodId + 1; i <= currentId; i++) {
-                totalWeight.push(totalWeight[i - 1]);
-            }
-        }
+        lastVotedPeriodId = 0;
     }
 
     // Reset votes to 0
     function reset() external {
-        // check if voting cycle is over then update ballotId
-        _updateCurrentId();
         _reset(msg.sender);
     }
 
@@ -781,14 +756,29 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function _reset(address _owner) internal {
         address[] storage _tokenVote = tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
+        uint256 currentId = getCurrentPeriodId();
+
+        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);
-                weights[_token][currentId] -= (_votes);
 
+                if (currentId > tokenLastVotedPeriodId[_token]) {
+                    weights[currentId][_token] = weights[
+                        tokenLastVotedPeriodId[_token]
+                    ][_token];
+
+                    tokenLastVotedPeriodId[_token] = currentId;
+                }
+
+                weights[currentId][_token] -= _votes;
                 votes[_owner][_token] = 0;
             }
         }
@@ -798,10 +788,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
     function poke(address _owner) public {
-        _updateCurrentId();
         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));
@@ -810,13 +800,14 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             int256 _prevWeight = votes[_owner][_tokenVote[i]];
             _weights[i] = (_prevWeight * (_weight)) / (_prevUsedWeight);
         }
-        _vote(_owner, _tokenVote, _weights);
+        _vote(_owner, _tokenVote, _weights, currentId);
     }
 
     function _vote(
         address _owner,
         address[] memory _tokenVote,
-        int256[] memory _weights
+        int256[] memory _weights,
+        uint256 _currentId
     ) internal {
         _reset(_owner);
         uint256 _tokenCnt = _tokenVote.length;
@@ -827,28 +818,34 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         for (uint256 i = 0; i < _tokenCnt; i++) {
             _totalVoteWeight += (_weights[i] > 0 ? _weights[i] : -_weights[i]);
         }
-        // uint256 i = 0;
+
+        if (_currentId > lastVotedPeriodId) {
+            totalWeight[_currentId] = totalWeight[lastVotedPeriodId];
+            lastVotedPeriodId = _currentId;
+        }
+
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
             int256 _tokenWeight = (_weights[i] * _weight) / _totalVoteWeight;
-            if (currentId == 0) {
-                weights[_token].push(0);
-            } else {
-                weights[_token].push(weights[_token][currentId - 1]);
-            }
+
             if (_gauge != address(0x0)) {
-                weights[_token][currentId] += _tokenWeight;
+                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;
-                }
+                if (_tokenWeight < 0) _tokenWeight = -_tokenWeight;
 
                 _usedWeight += _tokenWeight;
-                // totalWeight.push(0);
-                totalWeight[currentId] += _tokenWeight;
+                totalWeight[_currentId] += _tokenWeight;
             }
         }
 
@@ -863,8 +860,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             _tokenVote.length == _weights.length,
             "GaugeProxy: token votes count does not match weights count"
         );
-        _updateCurrentId();
-        _vote(msg.sender, _tokenVote, _weights);
+        uint256 currentId = getCurrentPeriodId();
+        _vote(msg.sender, _tokenVote, _weights, currentId);
         delegations[msg.sender].blockDelegate[currentId] = true;
     }
 
@@ -884,17 +881,17 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         delegateData storage _delegate = delegations[msg.sender];
 
-        uint256 actualCurrentPeriodId = getActualCurrentPeriodId();
+        uint256 currentPeriodId = getCurrentPeriodId();
 
         address currentDelegate = _delegate.delegate;
         _delegate.delegate = _delegateAddress;
         _delegate.prevDelegate = currentDelegate;
-        _delegate.updatePeriodId = actualCurrentPeriodId;
+        _delegate.updatePeriodId = currentPeriodId;
 
         if (_indefinite == true) {
             _delegate.indefinite = true;
         } else {
-            _delegate.endPeriod = actualCurrentPeriodId + _periodsCount;
+            _delegate.endPeriod = currentPeriodId + _periodsCount;
         }
     }
 
@@ -907,7 +904,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             _tokenVote.length == _weights.length,
             "GaugeProxy: token votes count does not match weights count"
         );
-        _updateCurrentId();
+
+        uint256 currentId = getCurrentPeriodId();
         delegateData storage _delegate = delegations[_owner];
         require(
             (_delegate.delegate == msg.sender &&
@@ -925,7 +923,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "Delegating period expired"
         );
 
-        _vote(_owner, _tokenVote, _weights);
+        _vote(_owner, _tokenVote, _weights, currentId);
     }
 
     // Add new token gauge
@@ -940,11 +938,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] != address(0x0), "!exists");
 
-        uint256 _actualCurrentId = getActualCurrentPeriodId();
-        require(
-            distributionId == _actualCurrentId - 1,
-            "! all distributions completed"
-        );
+        uint256 currentId = getCurrentPeriodId();
+        require(distributionId == currentId, "! all distributions completed");
 
         address _gauge = gauges[_token];
 
@@ -952,13 +947,18 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         delete gauges[_token];
 
-        // address[] storage newTokenArray = new address[]();
         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) _tokensTemp.push(_tokens[i]);
+            if (_tokens[i] != _token) {
+                newTokenArray[j] = _tokens[i];
+                j++;
+            }
         }
-        _tokens = _tokensTemp;
+
+        _tokens = newTokenArray;
     }
 
     // Sets MasterChef PID
@@ -990,6 +990,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         return _tokens.length;
     }
 
+    // WIP: Need to improve distribute syncing. Logic does not work if votes are skipped without calling distribute
     function distribute(uint256 _start, uint256 _end) external {
         require(_start < _end, "GaugeProxyV2: bad _start");
         require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
@@ -999,33 +1000,28 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         );
         _sender = msg.sender;
 
-        _updateCurrentId();
-        require(currentId > 0, "initial voting in progress");
+        uint256 currentId = getCurrentPeriodId();
         require(
-            // currentId == 0 ?
-            // distributionId == 0 :
             distributionId < currentId,
             "GaugeProxyV2: all period distributions complete"
         );
 
         collect();
         int256 _balance = int256(PICKLE.balanceOf(address(this)));
-        // int256 _totalWeight = currentId == 0
-        //     ? totalWeight[distributionId]
-        //     : totalWeight[distributionId + 1];
-        int256 _totalWeight =  totalWeight[distributionId];
+        int256 _totalWeight = distributionId > lastVotedPeriodId
+            ? totalWeight[lastVotedPeriodId]
+            : totalWeight[distributionId];
+
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
+                int256 tokenWeight = distributionId >
+                    tokenLastVotedPeriodId[_token]
+                    ? weights[tokenLastVotedPeriodId[_token]][_token]
+                    : weights[distributionId][_token];
                 uint256 _reward = uint256(
-                    (_balance *
-                        (
-                            weights[_token][distributionId]
-                            // currentId == 0
-                            //     ? weights[_token][distributionId]
-                            //     : weights[_token][distributionId + 1]
-                        )) / (_totalWeight)
+                    (_balance * tokenWeight) / (_totalWeight)
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);

From bd95e9fb3adc569f7f1375d7a89531686e01d61e Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 27 Apr 2022 19:53:23 +0530
Subject: [PATCH 19/55] WIP: more test coverage

---
 src/tests/dill/gaugeProxyV2Test.js | 185 +++++++++++++++++++++++++++++
 1 file changed, 185 insertions(+)
 create mode 100644 src/tests/dill/gaugeProxyV2Test.js

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]);
+    });
+  });
+});

From 9c7569e9b04b035a8ba9f8b7d68dfe5414592bf1 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 28 Apr 2022 12:28:21 +0530
Subject: [PATCH 20/55] feat: added fix for distribute to work without voting
 periods

---
 src/dill/gauge-proxy-v2.sol | 37 ++++++++++++++++++++++++-------------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 113c35583..a4953ac57 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -690,7 +690,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // token => gauge
     mapping(address => address) public gauges;
-
     mapping(address => uint256) public gaugeWithNegativeWeight;
 
     uint256 public constant WEEK_SECONDS = 604800;
@@ -707,6 +706,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     mapping(uint256 => mapping(address => int256)) public weights; // period id => token => weight
     mapping(uint256 => int256) public totalWeight; // period id => TotalWeight
 
+    mapping(uint256 => uint256) public periodForDistribute; // dist id => which period id votes to use
+
     struct delegateData {
         // delegated address
         address delegate;
@@ -727,7 +728,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function getCurrentPeriodId() public view returns (uint256) {
         return
             block.timestamp > firstDistribution
-                ? block.timestamp - firstDistribution / WEEK_SECONDS
+                ? (block.timestamp - firstDistribution / WEEK_SECONDS) + 1
                 : 0;
     }
 
@@ -743,8 +744,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         TOKEN = IERC20(address(new MasterDill()));
         governance = msg.sender;
         firstDistribution = _firstDistribution;
-        distributionId = 0;
-        lastVotedPeriodId = 0;
+        distributionId = 1;
+        lastVotedPeriodId = 1;
+        periodForDistribute[1] = 1;
     }
 
     // Reset votes to 0
@@ -757,6 +759,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] storage _tokenVote = tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
         uint256 currentId = getCurrentPeriodId();
+        require(currentId > 0, "Voting not started");
 
         if (currentId > lastVotedPeriodId) {
             totalWeight[currentId] = totalWeight[lastVotedPeriodId];
@@ -784,6 +787,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         delete tokenVote[_owner];
+        periodForDistribute[currentId] = currentId;
     }
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
@@ -809,6 +813,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         int256[] memory _weights,
         uint256 _currentId
     ) internal {
+        require(_currentId > 0, "Voting not started");
         _reset(_owner);
         uint256 _tokenCnt = _tokenVote.length;
         int256 _weight = int256(DILL.balanceOf(_owner));
@@ -850,6 +855,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         usedWeights[_owner] = _usedWeight;
+        periodForDistribute[_currentId] = _currentId;
     }
 
     // Vote with DILL on a gauge
@@ -990,7 +996,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         return _tokens.length;
     }
 
-    // WIP: Need to improve distribute syncing. Logic does not work if votes are skipped without calling distribute
     function distribute(uint256 _start, uint256 _end) external {
         require(_start < _end, "GaugeProxyV2: bad _start");
         require(_end <= _tokens.length, "GaugeProxyV2: bad _end");
@@ -1006,22 +1011,28 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "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 = distributionId > lastVotedPeriodId
-            ? totalWeight[lastVotedPeriodId]
-            : totalWeight[distributionId];
+        int256 _totalWeight = totalWeight[periodToUse];
 
         if (_balance > 0 && _totalWeight > 0) {
             for (uint256 i = _start; i < _end; i++) {
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
-                int256 tokenWeight = distributionId >
-                    tokenLastVotedPeriodId[_token]
-                    ? weights[tokenLastVotedPeriodId[_token]][_token]
-                    : weights[distributionId][_token];
                 uint256 _reward = uint256(
-                    (_balance * tokenWeight) / (_totalWeight)
+                    (_balance * weights[periodToUse][_token]) / (_totalWeight)
                 );
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);

From 8a2a59d27ad0d4af71a2fa241906c7c60028c9bf Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 28 Apr 2022 13:42:49 +0530
Subject: [PATCH 21/55] fix: minor updates

---
 src/dill/gauge-proxy-v2.sol | 41 ++++++++++++++++---------------------
 1 file changed, 18 insertions(+), 23 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index a4953ac57..8fadb09a9 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -697,7 +697,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     uint256 public firstDistribution;
     uint256 public distributionId;
     uint256 public lastVotedPeriodId;
-    address public _sender;
 
     mapping(address => uint256) public tokenLastVotedPeriodId; // token => last voted period id
     mapping(address => int256) public usedWeights; // msg.sender => total voting weight of user
@@ -751,19 +750,20 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
     // Reset votes to 0
     function reset() external {
-        _reset(msg.sender);
+        uint256 currentId = getCurrentPeriodId();
+        require(currentId > 0, "Voting not started yet");
+        _reset(msg.sender, currentId);
     }
 
     // Reset votes to 0
-    function _reset(address _owner) internal {
+    function _reset(address _owner, uint256 _currentId) internal {
         address[] storage _tokenVote = tokenVote[_owner];
         uint256 _tokenVoteCnt = _tokenVote.length;
-        uint256 currentId = getCurrentPeriodId();
-        require(currentId > 0, "Voting not started");
+        require(_currentId > 0, "Voting not started");
 
-        if (currentId > lastVotedPeriodId) {
-            totalWeight[currentId] = totalWeight[lastVotedPeriodId];
-            lastVotedPeriodId = currentId;
+        if (_currentId > lastVotedPeriodId) {
+            totalWeight[_currentId] = totalWeight[lastVotedPeriodId];
+            lastVotedPeriodId = _currentId;
         }
 
         for (uint256 i = 0; i < _tokenVoteCnt; i++) {
@@ -771,23 +771,24 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             int256 _votes = votes[_owner][_token];
 
             if (_votes != 0) {
-                totalWeight[currentId] -= (_votes > 0 ? _votes : -_votes);
+                totalWeight[_currentId] -= (_votes > 0 ? _votes : -_votes);
 
-                if (currentId > tokenLastVotedPeriodId[_token]) {
-                    weights[currentId][_token] = weights[
+                if (_currentId > tokenLastVotedPeriodId[_token]) {
+                    weights[_currentId][_token] = weights[
                         tokenLastVotedPeriodId[_token]
                     ][_token];
 
-                    tokenLastVotedPeriodId[_token] = currentId;
+                    tokenLastVotedPeriodId[_token] = _currentId;
                 }
 
-                weights[currentId][_token] -= _votes;
+                weights[_currentId][_token] -= _votes;
                 votes[_owner][_token] = 0;
             }
         }
 
         delete tokenVote[_owner];
-        periodForDistribute[currentId] = currentId;
+        // Ensure distribute rewards are for current period 
+        periodForDistribute[_currentId] = _currentId;
     }
 
     // Adjusts _owner's votes according to latest _owner's DILL balance
@@ -813,8 +814,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         int256[] memory _weights,
         uint256 _currentId
     ) internal {
-        require(_currentId > 0, "Voting not started");
-        _reset(_owner);
+        _reset(_owner, _currentId);
         uint256 _tokenCnt = _tokenVote.length;
         int256 _weight = int256(DILL.balanceOf(_owner));
         int256 _totalVoteWeight = 0;
@@ -824,11 +824,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             _totalVoteWeight += (_weights[i] > 0 ? _weights[i] : -_weights[i]);
         }
 
-        if (_currentId > lastVotedPeriodId) {
-            totalWeight[_currentId] = totalWeight[lastVotedPeriodId];
-            lastVotedPeriodId = _currentId;
-        }
-
         for (uint256 i = 0; i < _tokenCnt; i++) {
             address _token = _tokenVote[i];
             address _gauge = gauges[_token];
@@ -855,7 +850,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         usedWeights[_owner] = _usedWeight;
-        periodForDistribute[_currentId] = _currentId;
     }
 
     // Vote with DILL on a gauge
@@ -867,6 +861,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "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;
     }
@@ -912,6 +907,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         );
 
         uint256 currentId = getCurrentPeriodId();
+        require(currentId > 0, "Voting not started yet");
         delegateData storage _delegate = delegations[_owner];
         require(
             (_delegate.delegate == msg.sender &&
@@ -1003,7 +999,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             msg.sender == governance,
             "GaugeProxyV2: only governance can distribute"
         );
-        _sender = msg.sender;
 
         uint256 currentId = getCurrentPeriodId();
         require(

From aa8e4fc4b0f7bf1894ce168cf69cdb05b026b7db Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 28 Apr 2022 17:04:32 +0530
Subject: [PATCH 22/55] feat: chunk distribution test

---
 .../01_gaugeProxyV2_chunkDistTest.test.js     | 162 ++++++++++++++++++
 src/tests/dill/testHelper.js                  |  20 +++
 2 files changed, 182 insertions(+)
 create mode 100644 src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
 create mode 100644 src/tests/dill/testHelper.js

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..5db1efd4b
--- /dev/null
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -0,0 +1,162 @@
+const {advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+// const {describe, it, before} = require("mocha");
+
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
+const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+
+describe("vote & distribute : chunk and onlyGov distribution", () => {
+  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("onlyGov : distribution by non-gov address should fail", async () => {
+      const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+      populatedTx = await gaugeProxyFromUser.populateTransaction.distribute(0, 2);
+      await userSigner.sendTransaction(populatedTx);
+    });
+    it("Distribute(onlyGov) PICKLE to gauges should fail as voting still in progress", async () => {
+      await GaugeProxyV2.distribute(0, 2);
+    });
+
+    it("distribution should fail when end greater than token[] length is passed ", async () => {
+      await advanceSevenDays();
+      await GaugeProxyV2.distribute(0, 3);
+    });
+
+    it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
+      /**
+       * FIRST CHUNK DISTRIBUTION (successful)
+       */
+      console.log("distributing first chunk");
+      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());
+    });
+
+    it("should fail when tried to distribute same chunk again", async () => {
+        /**
+         * FIRST CHUNK DISTRIBUTION (fail)
+         */
+        console.log("distributing first chunk");
+        await GaugeProxyV2.distribute(0, 1);
+        
+      });
+
+    it("should fail when tried to pass wrong start", async () => {
+      /**
+       * SECOND CHUNK DISTRIBUTION (fail)
+       */
+      console.log("distributing first chunk");
+      await GaugeProxyV2.distribute(0, 2);
+     
+    });
+
+    it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
+      /**
+       * SECOND CHUNK DISTRIBUTION (successful)
+       */
+      console.log("distributing second chunk");
+      console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+      console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+      await GaugeProxyV2.distribute(1, 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());
+    });
+  });
+});
diff --git a/src/tests/dill/testHelper.js b/src/tests/dill/testHelper.js
new file mode 100644
index 000000000..487708ac5
--- /dev/null
+++ b/src/tests/dill/testHelper.js
@@ -0,0 +1,20 @@
+const hre = require("hardhat");
+
+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",
+  });
+}
+
+module.exports = {
+  advanceSevenDays,
+};

From be8dd3b0f538148b82e52ff11a7a3b5daca71f82 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 28 Apr 2022 17:36:33 +0530
Subject: [PATCH 23/55] fix: currentId

---
 src/dill/gauge-proxy-v2.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 8fadb09a9..73ac3cb5a 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -727,7 +727,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function getCurrentPeriodId() public view returns (uint256) {
         return
             block.timestamp > firstDistribution
-                ? (block.timestamp - firstDistribution / WEEK_SECONDS) + 1
+                ? ((block.timestamp - firstDistribution) / WEEK_SECONDS) + 1
                 : 0;
     }
 

From e979be461219e4288313d4dd5d06a529926f62c4 Mon Sep 17 00:00:00 2001
From: Larry the Cucumber <larrythecucumber321@gmail.com>
Date: Thu, 28 Apr 2022 23:51:03 -0700
Subject: [PATCH 24/55] fix brackets

---
 src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
index 5db1efd4b..b8e27adbb 100644
--- a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -71,6 +71,8 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
       method: "evm_unlockUnknownAccount",
       params: [userAddr],
     });
+  });
+
 
     it("should vote successfully (first voting)", async () => {
       console.log("-- Voting on LP Gauge with 100% weight --");
@@ -158,5 +160,4 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
       let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
       console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
     });
-  });
 });

From 176e0ef37d2170aed562c1e245960eb5aed69147 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 29 Apr 2022 21:05:48 +0530
Subject: [PATCH 25/55] WIP: expect statements

---
 .../01_gaugeProxyV2_chunkDistTest.test.js     |  57 +++---
 .../dill/02_gaugeProxyV2_periodizationTest.js | 147 ++++++++++++++++
 .../dill/03_gaugeProcyV2_delegationTest.js    | 166 ++++++++++++++++++
 3 files changed, 347 insertions(+), 23 deletions(-)
 create mode 100644 src/tests/dill/02_gaugeProxyV2_periodizationTest.js
 create mode 100644 src/tests/dill/03_gaugeProcyV2_delegationTest.js

diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
index b8e27adbb..50a6502a4 100644
--- a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -2,7 +2,7 @@ const {advanceSevenDays} = require("./testHelper");
 const hre = require("hardhat");
 const {ethers, upgrades} = require("hardhat");
 // const {describe, it, before} = require("mocha");
-
+const { expect } = require("chai");
 
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
 const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
@@ -10,6 +10,7 @@ const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
+let GaugeProxyV2, userSigner, populatedTx, masterChef ;
 
 describe("vote & distribute : chunk and onlyGov distribution", () => {
   before("setting up gaugeProxyV2", async () => {
@@ -32,8 +33,8 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
     });
 
     const governanceSigner = ethers.provider.getSigner(governanceAddr);
-    const userSigner = ethers.provider.getSigner(userAddr);
-    const masterChef = await ethers.getContractAt(
+    userSigner = ethers.provider.getSigner(userAddr);
+    masterChef = await ethers.getContractAt(
       "src/yield-farming/masterchef.sol:MasterChef",
       masterChefAddr,
       governanceSigner
@@ -44,7 +45,7 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
     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()], {
+    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
       initializer: "initialize",
     });
     await GaugeProxyV2.deployed();
@@ -52,7 +53,7 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
 
     const mDILLAddr = await GaugeProxyV2.TOKEN();
     console.log("-- Adding mDILL to MasterChef --");
-    let populatedTx;
+    
     populatedTx = await masterChef.populateTransaction.add(
       5000000,
       mDILLAddr,
@@ -94,15 +95,25 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
     it("onlyGov : distribution by non-gov address should fail", async () => {
       const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
       populatedTx = await gaugeProxyFromUser.populateTransaction.distribute(0, 2);
-      await userSigner.sendTransaction(populatedTx);
+      // await userSigner.sendTransaction(populatedTx);
+      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 GaugeProxyV2.distribute(0, 2);
+      // await GaugeProxyV2.distribute(0, 2);
+      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 GaugeProxyV2.distribute(0, 3);
+      // await GaugeProxyV2.distribute(0, 3);
+      await expect(
+        GaugeProxyV2.distribute(0, 3)
+      ).to.be.revertedWith("GaugeProxyV2: bad _end");
     });
 
     it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
@@ -123,23 +134,23 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
       console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
     });
 
-    it("should fail when tried to distribute same chunk again", async () => {
-        /**
-         * FIRST CHUNK DISTRIBUTION (fail)
-         */
-        console.log("distributing first chunk");
-        await GaugeProxyV2.distribute(0, 1);
+    // it("should revert when tried to distribute same chunk again", async () => {
+    //     /**
+    //      * FIRST CHUNK DISTRIBUTION (fail)
+    //      */
+    //     console.log("distributing first chunk");
+    //     await GaugeProxyV2.distribute(0, 1);
         
-      });
-
-    it("should fail when tried to pass wrong start", async () => {
-      /**
-       * SECOND CHUNK DISTRIBUTION (fail)
-       */
-      console.log("distributing first chunk");
-      await GaugeProxyV2.distribute(0, 2);
+    //   });
+
+    // it("should fail when tried to pass wrong start", async () => {
+    //   /**
+    //    * SECOND CHUNK DISTRIBUTION (fail)
+    //    */
+    //   console.log("distributing first chunk");
+    //   await GaugeProxyV2.distribute(0, 2);
      
-    });
+    // });
 
     it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
       /**
diff --git a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
new file mode 100644
index 000000000..911d23d10
--- /dev/null
+++ b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
@@ -0,0 +1,147 @@
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+// const {describe, it, before} = require("mocha");
+const {advanceSevenDays} = require("./testHelper");
+
+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((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);
+    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...");
+    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);
+
+    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("Distribution(initial) should fail as voting for current(initial) period is still in progress", async () => {
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+    await GaugeProxyV2.distribute(0, 2);
+  });
+
+  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 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 () => {
+    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
+    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
+    await GaugeProxyV2.distribute(0, 2);
+  });
+
+  it("should distribute similar rewards for the periods users have not voted for (advancing 3 weeks)", async () => {
+    console.log("advancing 3 weeks");
+    await advanceSevenDays();
+    await advanceSevenDays();
+    await advanceSevenDays();
+
+    const cid = await GaugeProxyV2.getCurrentPeriodId();
+    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);
+      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());
+    }
+  });
+});
diff --git a/src/tests/dill/03_gaugeProcyV2_delegationTest.js b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
new file mode 100644
index 000000000..21a81f8c4
--- /dev/null
+++ b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
@@ -0,0 +1,166 @@
+const hre = require("hardhat");
+const {ethers, upgrades} = require("hardhat");
+// const {describe, it, before} = require("mocha");
+const {advanceSevenDays} = require("./testHelper");
+
+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((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);
+    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...");
+    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);
+
+    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 set delegate successfully ", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(governanceAddr, 1, false);
+    await userSigner.sendTransaction(populatedTx);
+
+    // await GaugeProxyV2.setVotingDelegate(governanceAddr, 1, false);
+  });
+
+  it("delegate should vote successfully for user", async () => {
+    /** here gov will vote on behalf of user */
+    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000, 4000000]);
+  });
+
+  it("should set pid successfully", 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("should distribute successfully after delegate has voted", async () => {
+    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 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 gas expired", async () => {
+    /** here gov will vote on behalf of user */
+    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000, 4000000]);
+  });
+
+  it("should set delegate successfully ", async () => {
+    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(governanceAddr, 1, false);
+    await userSigner.sendTransaction(populatedTx);
+  });
+
+  it("delegate should vote successfully for user", async () => {
+    /** here gov will vote on behalf of user */
+    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000]);
+  });
+
+  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 GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000]);
+  });
+  it("should distribute(after 1 week) successfully after owner has overwritten delegated vote", 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 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());
+  });
+});

From cd6b27821f66f8e0a63a65b89b8e7f527bb23d82 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 13 May 2022 13:37:58 +0530
Subject: [PATCH 26/55] feat: GaugeProxyV2 tests

---
 src/dill/gauge-proxy-v2.sol                   |  14 +-
 .../01_gaugeProxyV2_chunkDistTest.test.js     | 191 +++++++++---------
 .../dill/02_gaugeProxyV2_periodizationTest.js |  94 ++++++---
 .../dill/03_gaugeProcyV2_delegationTest.js    | 116 +++++------
 src/tests/dill/testHelper.js                  |  36 +++-
 5 files changed, 254 insertions(+), 197 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 73ac3cb5a..7f62c38f2 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -704,7 +704,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     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
 
     struct delegateData {
@@ -787,7 +787,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         delete tokenVote[_owner];
-        // Ensure distribute rewards are for current period 
+        // Ensure distribute rewards are for current period
         periodForDistribute[_currentId] = _currentId;
     }
 
@@ -891,6 +891,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         if (_indefinite == true) {
             _delegate.indefinite = true;
+        } else if (_delegate.prevDelegate == address(0)) {
+            _delegate.endPeriod = currentPeriodId + _periodsCount - 1;
         } else {
             _delegate.endPeriod = currentPeriodId + _periodsCount;
         }
@@ -913,6 +915,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             (_delegate.delegate == msg.sender &&
                 currentId > _delegate.updatePeriodId) ||
                 (_delegate.prevDelegate == msg.sender &&
+                    currentId == _delegate.updatePeriodId) ||
+                (_delegate.prevDelegate == address(0) &&
                     currentId == _delegate.updatePeriodId),
             "Sender not authorized"
         );
@@ -921,7 +925,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             "Delegating address has already voted"
         );
         require(
-            _delegate.indefinite == true || _delegate.endPeriod <= currentId,
+            (_delegate.indefinite || currentId <= _delegate.endPeriod),
             "Delegating period expired"
         );
 
@@ -1024,6 +1028,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
         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];
                 uint256 _reward = uint256(
@@ -1038,6 +1045,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 if (_reward < 0) {
                     gaugeWithNegativeWeight[_gauge] += 1;
                 }
+                distributed[distributionId][i] = true;
             }
         }
 
diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
index 50a6502a4..1193dcaaa 100644
--- a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -1,8 +1,7 @@
 const {advanceSevenDays} = require("./testHelper");
 const hre = require("hardhat");
 const {ethers, upgrades} = require("hardhat");
-// const {describe, it, before} = require("mocha");
-const { expect } = require("chai");
+const {expect} = require("chai");
 
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
 const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
@@ -10,15 +9,14 @@ const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
-let GaugeProxyV2, userSigner, populatedTx, masterChef ;
+let GaugeProxyV2, userSigner, populatedTx, masterChef;
 
-describe("vote & distribute : chunk and onlyGov distribution", () => {
-  before("setting up gaugeProxyV2", async () => {
+describe("Vote & Distribute : chunk and onlyGov distribution", () => {
+  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,
@@ -44,7 +42,6 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
     /** 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...");
     GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
       initializer: "initialize",
     });
@@ -53,12 +50,11 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
 
     const mDILLAddr = await GaugeProxyV2.TOKEN();
     console.log("-- Adding mDILL to MasterChef --");
-    
+
     populatedTx = await masterChef.populateTransaction.add(
       5000000,
       mDILLAddr,
       false
-      // { gasLimit: 9000000 }
     );
     await governanceSigner.sendTransaction(populatedTx);
 
@@ -74,101 +70,108 @@ describe("vote & distribute : chunk and onlyGov distribution", () => {
     });
   });
 
+  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);
+  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();
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
 
-      await hre.network.provider.request({
-        method: "evm_mine",
-      });
+    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 userSigner.sendTransaction(populatedTx);
-      await expect(
-        userSigner.sendTransaction(populatedTx)
-      ).to.be.revertedWith("GaugeProxyV2: only governance can distribute");
-    });
+  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 GaugeProxyV2.distribute(0, 2);
-      await expect(
-        GaugeProxyV2.distribute(0, 2)
-      ).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
-    });
+  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 GaugeProxyV2.distribute(0, 3);
-      await expect(
-        GaugeProxyV2.distribute(0, 3)
-      ).to.be.revertedWith("GaugeProxyV2: bad _end");
-    });
+  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 to gauges in chunks after advancing 7 days", async () => {
-      /**
-       * FIRST CHUNK DISTRIBUTION (successful)
-       */
-      console.log("distributing first chunk");
-      await GaugeProxyV2.distribute(0, 1);
-      let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
-      let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
+  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);
+    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);
+  });
 
-      const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
+  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);
+   
+    let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
+    let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
 
-      let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
-      console.log("rewards to Pickle gauge", pickleRewards.toString());
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
 
-      let yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
-      console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
-    });
+    let pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("Rewards to Pickle gauge => ", pickleRewards.toString());
 
-    // it("should revert when tried to distribute same chunk again", async () => {
-    //     /**
-    //      * FIRST CHUNK DISTRIBUTION (fail)
-    //      */
-    //     console.log("distributing first chunk");
-    //     await GaugeProxyV2.distribute(0, 1);
-        
-    //   });
-
-    // it("should fail when tried to pass wrong start", async () => {
-    //   /**
-    //    * SECOND CHUNK DISTRIBUTION (fail)
-    //    */
-    //   console.log("distributing first chunk");
-    //   await GaugeProxyV2.distribute(0, 2);
-     
-    // });
-
-    it("successfully Distribute PICKLE to gauges in chunks after advancing 7 days", async () => {
-      /**
-       * SECOND CHUNK DISTRIBUTION (successful)
-       */
-      console.log("distributing second chunk");
-      console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
-      console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
-      await GaugeProxyV2.distribute(1, 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());
-    });
+    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);
+    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_periodizationTest.js b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
index 911d23d10..34f1b7a52 100644
--- a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
+++ b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
@@ -1,7 +1,7 @@
 const hre = require("hardhat");
 const {ethers, upgrades} = require("hardhat");
-// const {describe, it, before} = require("mocha");
 const {advanceSevenDays} = require("./testHelper");
+const {expect} = require("chai");
 
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
 const masterChefAddr = "0xbD17B1ce622d73bD438b9E658acA5996dc394b0d";
@@ -11,13 +11,12 @@ const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
 let GaugeProxyV2, userSigner, populatedTx, masterChef ;
 
-describe("vote & distribute", () => {
-  before("setting up gaugeProxyV2", async () => {
+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,
@@ -43,7 +42,6 @@ describe("vote & distribute", () => {
     /** 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...");
     GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
       initializer: "initialize",
     });
@@ -71,8 +69,15 @@ describe("vote & distribute", () => {
       method: "evm_unlockUnknownAccount",
       params: [userAddr],
     });
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
   });
-  it("should vote successfully (first voting)", async () => {
+  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], {
@@ -80,68 +85,97 @@ describe("vote & distribute", () => {
     });
     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("Distribution(initial) should fail as voting for current(initial) period is still in progress", async () => {
-    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
-    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
-    await GaugeProxyV2.distribute(0, 2);
+    await expect(GaugeProxyV2.distribute(0, 2)).to.be.revertedWith("GaugeProxyV2: all period distributions complete");
   });
 
-  it("successfully Distribute(initial) PICKLE to gauges advancing 7 days", async () => {
+  it("Successfully Distribute(initial) PICKLE to gauges after 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 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());
+    let pickleRewards = Number(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());
+    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 () => {
-    console.log("currentId", (await GaugeProxyV2.getCurrentPeriodId()).toString());
-    console.log("distributionId", (await GaugeProxyV2.distributionId()).toString());
-    await GaugeProxyV2.distribute(0, 2);
+    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 () => {
-    console.log("advancing 3 weeks");
+  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("currentId", cid.toString());
-    console.log("distributionId", did.toString());
+    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);
+      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());
+      console.log("Rewards to Pickle gauge", pickleRewards.toString());
 
       const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
-      console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+      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_delegationTest.js b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
index 21a81f8c4..1c6c6f5cc 100644
--- a/src/tests/dill/03_gaugeProcyV2_delegationTest.js
+++ b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
@@ -1,6 +1,7 @@
+const {expect} = require("chai");
 const hre = require("hardhat");
 const {ethers, upgrades} = require("hardhat");
-// const {describe, it, before} = require("mocha");
+
 const {advanceSevenDays} = require("./testHelper");
 
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
@@ -11,13 +12,12 @@ const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
 let GaugeProxyV2, userSigner, populatedTx, masterChef;
 
-describe("vote & distribute", () => {
-  before("setting up gaugeProxyV2", async () => {
+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,
@@ -43,7 +43,6 @@ describe("vote & distribute", () => {
     /** 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...");
     GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
       initializer: "initialize",
     });
@@ -53,12 +52,7 @@ describe("vote & distribute", () => {
     const mDILLAddr = await GaugeProxyV2.TOKEN();
     console.log("-- Adding mDILL to MasterChef --");
     let populatedTx;
-    populatedTx = await masterChef.populateTransaction.add(
-      5000000,
-      mDILLAddr,
-      false
-      // { gasLimit: 9000000 }
-    );
+    populatedTx = await masterChef.populateTransaction.add(5000000, mDILLAddr, false);
     await governanceSigner.sendTransaction(populatedTx);
 
     console.log("-- Adding PICKLE LP Gauge --");
@@ -71,72 +65,51 @@ describe("vote & distribute", () => {
       method: "evm_unlockUnknownAccount",
       params: [userAddr],
     });
+    const pidDill = (await masterChef.poolLength()) - 1;
+    await GaugeProxyV2.setPID(pidDill);
+    await GaugeProxyV2.deposit();
   });
-  it("should set delegate successfully ", async () => {
+  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, 1, false);
+    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(governanceAddr, 2, false);
     await userSigner.sendTransaction(populatedTx);
-
-    // await GaugeProxyV2.setVotingDelegate(governanceAddr, 1, false);
   });
-
-  it("delegate should vote successfully for user", async () => {
+  
+  it("delegate vote should fail as votes count does not match weights count", async () => {
     /** here gov will vote on behalf of user */
-    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000, 4000000]);
+    await expect(GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000])).to.be.revertedWith(
+      "token votes count does not match weights count"
+    );
   });
 
-  it("should set pid successfully", 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("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);
 
-  it("should distribute successfully after delegate has voted", async () => {
-    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 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());
-    });
-  });
+    const pickle = await ethers.getContractAt("src/yield-farming/pickle-token.sol:PickleToken", pickleAddr);
 
-  it("delegate vote should fail for user as delegation period gas expired", async () => {
-    /** here gov will vote on behalf of user */
-    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [6000000, 4000000]);
-  });
+    const pickleRewards = await pickle.balanceOf(pickleGaugeAddr);
+    console.log("rewards to Pickle gauge => ", pickleRewards.toString());
 
-  it("should set delegate successfully ", async () => {
-    const gaugeProxyFromUser = GaugeProxyV2.connect(userAddr);
-    populatedTx = await gaugeProxyFromUser.populateTransaction.setVotingDelegate(governanceAddr, 1, false);
-    await userSigner.sendTransaction(populatedTx);
+    const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
+    console.log("rewards to pyveCRV gauge => ", yvecrvRewards.toString());
   });
 
-  it("delegate should vote successfully for user", async () => {
+  it("delegate should vote again successfully ", async () => {
     /** here gov will vote on behalf of user */
-    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000]);
+    await GaugeProxyV2.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], {
@@ -145,12 +118,12 @@ describe("vote & distribute", () => {
     await userSigner.sendTransaction(populatedTx);
   });
   it("delegate should not be able to vote if owner has already voted for current period", async () => {
-    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000]);
+    await expect(
+    GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000])
+    ).to.be.revertedWith("Delegating address has already voted");
   });
-  it("should distribute(after 1 week) successfully after owner has overwritten delegated vote", async () => {
+  it("Successfully Distribute 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);
@@ -158,9 +131,16 @@ describe("vote & distribute", () => {
     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());
+    console.log("rewards to Pickle gauge => ", pickleRewards.toString());
 
     const yvecrvRewards = await pickle.balanceOf(yvecrvGaugeAddr);
-    console.log("rewards to pyveCRV gauge", yvecrvRewards.toString());
+    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.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000])
+    ).to.be.revertedWith("Delegating period expired");
+  }); 
 });
diff --git a/src/tests/dill/testHelper.js b/src/tests/dill/testHelper.js
index 487708ac5..97c380e4c 100644
--- a/src/tests/dill/testHelper.js
+++ b/src/tests/dill/testHelper.js
@@ -1,20 +1,52 @@
 const hre = require("hardhat");
+const {ethers} = require("hardhat");
+
+// const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+// const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
 
 async function advanceSevenDays() {
   /** ************************************* increase time by 7 days ****************************************** */
-  console.log("-- Wait 7 days to accumulate");
+  console.log("-- Advancing 7 dyas --");
   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",
   });
 }
 
+/**
+ * 
+ * @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 = {
   advanceSevenDays,
+  distribute,
 };

From 3d8c9a16bc90fe1fe93654249a7f00b622e96038 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 25 May 2022 12:37:58 +0530
Subject: [PATCH 27/55] fix: minor fix

---
 src/dill/gauge-proxy-v2.sol | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 7f62c38f2..2f7af4bfd 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -828,7 +828,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
             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[
@@ -848,7 +847,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 totalWeight[_currentId] += _tokenWeight;
             }
         }
-
         usedWeights[_owner] = _usedWeight;
     }
 
@@ -1033,13 +1031,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 }
                 address _token = _tokens[i];
                 address _gauge = gauges[_token];
-                uint256 _reward = uint256(
-                    (_balance * weights[periodToUse][_token]) / (_totalWeight)
-                );
+                int256 _reward = (_balance * weights[periodToUse][_token]) /
+                    _totalWeight;
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
-                    PICKLE.safeApprove(_gauge, _reward);
-                    Gauge(_gauge).notifyRewardAmount(_reward);
+                    PICKLE.safeApprove(_gauge, uint256(_reward));
+                    Gauge(_gauge).notifyRewardAmount(uint256(_reward));
                 }
 
                 if (_reward < 0) {

From dba89159a00587a0e242b4c58ad60351f3cc6bac Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 7 Jun 2022 12:41:33 +0530
Subject: [PATCH 28/55] feat: added support for time locking in Gauge V2

---
 src/dill/gauge-proxy.sol | 311 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 310 insertions(+), 1 deletion(-)

diff --git a/src/dill/gauge-proxy.sol b/src/dill/gauge-proxy.sol
index 6b7888bf7..c74f51eb4 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) {
@@ -384,6 +385,314 @@ contract Gauge is ReentrancyGuard {
     event RewardPaid(address indexed user, uint256 reward);
 }
 
+contract GaugeV2 is ReentrancyGuard {
+    using SafeMath for uint256;
+    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 MULTIPLIER_PRECISION = 1e18;
+
+    IERC20 public immutable TOKEN;
+    address public immutable DISTRIBUTION;
+    uint256 public constant DURATION = 7 days;
+    
+    // Lock time and multiplier settings
+    uint256 public lock_max_multiplier = uint256(25e17); // E18. 1x = e18
+    uint256 public lock_time_for_max_multiplier = 1 * 365 * 86400; // 1 year
+    uint256 public lock_time_min = 86400; // 1 * 86400  (1 day)
+
+    // Time tracking
+    uint256 public periodFinish = 0;
+    uint256 public lastUpdateTime;
+    
+    // Rewards tracking
+    mapping(address => uint256) public userRewardPerTokenPaid;
+    mapping(address => uint256) public rewards;
+    uint256 public rewardPerTokenStored;
+    uint256 public rewardRate = 0;
+    mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
+
+    // Balance tracking
+    uint256 private _totalSupply;
+    uint public derivedSupply;
+    mapping(address => uint256) private _balances;
+    mapping(address => uint256) public derivedBalances;
+    mapping(address => uint) private _base;
+
+    // Stake tracking 
+    mapping(address => LockedStake[]) private lockedStakes;
+
+    /* ========== STRUCTS ========== */
+
+    struct LockedStake {
+        bytes32 kek_id;
+        uint256 start_timestamp;
+        uint256 liquidity;
+        uint256 ending_timestamp;
+        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+    }
+
+    /* ========== MODIFIERS ========== */
+
+    modifier onlyDistribution() {
+        require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
+        _;
+    }
+
+    modifier updateReward(address account) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateTime = lastTimeRewardApplicable();
+        if (account != address(0)) {
+            rewards[account] = earned(account);
+            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+        }
+        _;
+        if (account != address(0)) {
+            kick(account);
+        }
+    }
+
+    /* ========== CONSTRUCTOR ========== */
+
+    constructor(address _token) public {
+        TOKEN = IERC20(_token);
+        DISTRIBUTION = msg.sender;
+    }
+    
+    /* ========== 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) {
+        if (_totalSupply == 0) {
+            return rewardPerTokenStored;
+        }
+        return
+            rewardPerTokenStored.add(
+                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(derivedSupply)
+            );
+    }
+
+    function derivedBalance(address account) public view returns (uint256) {
+        uint256 _balance = _balances[account];
+        uint256 _derived = _balance.mul(40).div(100);
+        uint256 _adjusted = (_totalSupply.mul(DILL.balanceOf(account)).div(DILL.totalSupply())).mul(60).div(100);
+        uint256 dillBoostedDerivedBal = Math.min(_derived.add(_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;
+
+            // If the lock is expired
+            if (thisStake.ending_timestamp <= block.timestamp) {
+                // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
+                if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
+                    uint256 time_before_expiry = (thisStake.ending_timestamp).sub(lastRewardClaimTime[account]);
+                    uint256 time_after_expiry = (block.timestamp).sub(thisStake.ending_timestamp);
+
+                    // Get the weighted-average lock_multiplier
+                    uint256 numerator = ((lock_multiplier).mul(time_before_expiry)).add(((MULTIPLIER_PRECISION).mul(time_after_expiry)));
+                    lock_multiplier = numerator.div(time_before_expiry.add(time_after_expiry));
+                }
+                // Otherwise, it needs to just be 1x
+                else {
+                    lock_multiplier = MULTIPLIER_PRECISION;
+                }
+            }
+
+            uint256 liquidity = thisStake.liquidity;
+            uint256 combined_boosted_amount = liquidity.mul(lock_multiplier).div(MULTIPLIER_PRECISION);
+            lockBoostedDerivedBal = lockBoostedDerivedBal.add(combined_boosted_amount);
+        }
+
+        return dillBoostedDerivedBal.add(lockBoostedDerivedBal);
+    }
+
+    // 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) {
+        return derivedBalances[account]
+            .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
+            .div(1e18)
+            .add(rewards[account]);
+    }
+
+    function getRewardForDuration() external view returns (uint256) {
+        return rewardRate.mul(DURATION);
+    }
+
+    // Multiplier amount, given the length of the lock
+    function lockMultiplier(uint256 secs) public view returns (uint256) {
+        uint256 lock_multiplier =
+            uint256(MULTIPLIER_PRECISION).add(
+                secs
+                    .mul(lock_max_multiplier.sub(MULTIPLIER_PRECISION))
+                    .div(lock_time_for_max_multiplier)
+            );
+        if (lock_multiplier > lock_max_multiplier) lock_multiplier = lock_max_multiplier;
+        return lock_multiplier;
+    }
+    
+    /* ========== MUTATIVE FUNCTIONS ========== */
+
+    function kick(address account) public {
+        uint _derivedBalance = derivedBalances[account];
+        derivedSupply = derivedSupply.sub(_derivedBalance);
+        _derivedBalance = derivedBalance(account);
+        derivedBalances[account] = _derivedBalance;
+        derivedSupply = derivedSupply.add(_derivedBalance);
+    }
+    
+    function depositAll(uint256 secs) external {
+        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, secs, block.timestamp);
+    }
+    
+    function deposit(uint256 amount, uint256 secs) external {
+        _deposit(amount, msg.sender, secs, block.timestamp);
+    }
+    
+    function depositFor(uint256 amount, address account, uint256 secs) external {
+        _deposit(amount, account, secs, block.timestamp);
+    }
+    
+    function _deposit(
+        uint amount,
+        address account,
+        uint256 secs,
+        uint256 start_timestamp
+    ) internal nonReentrant updateReward(account) {
+        require(amount > 0, "Cannot stake 0");
+        uint256 lock_multiplier = lockMultiplier(secs);
+        bytes32 kek_id = keccak256(abi.encodePacked(account, start_timestamp, amount, _balances[account]));
+        lockedStakes[account].push(LockedStake(
+            kek_id,
+            start_timestamp,
+            amount,
+            start_timestamp.add(secs),
+            lock_multiplier
+        ));
+
+        TOKEN.safeTransferFrom(account, address(this), amount);
+
+        _totalSupply = _totalSupply.add(amount);
+        _balances[account] = _balances[account].add(amount);
+
+        // 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, kek_id);
+    }
+
+    function withdraw(bytes32 kek_id) external {
+        _withdraw(kek_id);
+    }
+
+    function withdrawAll() public nonReentrant updateReward(msg.sender) {
+        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
+            uint256 liquidity = lockedStakes[msg.sender][i].liquidity;
+            if (liquidity > 0){
+                _totalSupply = _totalSupply.sub(liquidity);
+                _balances[msg.sender] = _balances[msg.sender].sub(liquidity);
+                delete lockedStakes[msg.sender][i];
+                TOKEN.safeTransfer(msg.sender, liquidity);
+                emit Withdrawn(msg.sender, liquidity, lockedStakes[msg.sender][i].kek_id);
+            }
+        }
+    }
+    
+    function _withdraw(bytes32 kek_id) internal nonReentrant updateReward(msg.sender) {
+        LockedStake memory thisStake;
+        thisStake.liquidity = 0;
+        uint theArrayIndex;
+        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
+            if (kek_id == lockedStakes[msg.sender][i].kek_id){
+                thisStake = lockedStakes[msg.sender][i];
+                theArrayIndex = i;
+                break;
+            }
+        }
+
+        require(thisStake.kek_id == kek_id, "Stake not found");
+        require(block.timestamp >= thisStake.ending_timestamp, "Stake is still locked!");
+
+        uint256 liquidity = thisStake.liquidity;
+
+        if (liquidity > 0) {
+            _totalSupply = _totalSupply.sub(liquidity);
+            _balances[msg.sender] = _balances[msg.sender].sub(liquidity);
+            delete lockedStakes[msg.sender][theArrayIndex];
+            TOKEN.safeTransfer(msg.sender, liquidity);
+        }
+
+        emit Withdrawn(msg.sender, liquidity, kek_id);
+    }
+
+    function getReward() public nonReentrant updateReward(msg.sender) {
+        uint256 reward = rewards[msg.sender];
+        if (reward > 0) {
+            rewards[msg.sender] = 0;
+            PICKLE.safeTransfer(msg.sender, reward);
+            emit RewardPaid(msg.sender, reward);
+        }
+    }
+
+    function exit() external {
+        withdrawAll();
+        getReward();
+    }
+    
+    /* ========== RESTRICTED FUNCTIONS ========== */
+
+    function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
+        PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
+        if (block.timestamp >= periodFinish) {
+            rewardRate = reward.div(DURATION);
+        } else {
+            uint256 remaining = periodFinish.sub(block.timestamp);
+            uint256 leftover = remaining.mul(rewardRate);
+            rewardRate = reward.add(leftover).div(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.
+        uint balance = PICKLE.balanceOf(address(this));
+        require(rewardRate <= balance.div(DURATION), "Provided reward too high");
+
+        lastUpdateTime = block.timestamp;
+        periodFinish = block.timestamp.add(DURATION);
+        emit RewardAdded(reward);
+    }
+
+    /* ========== EVENTS ========== */
+
+    event RewardAdded(uint256 reward);
+    event Staked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id);
+    event Withdrawn(address indexed user, uint256 amount, bytes32 kek_id);
+    event RewardPaid(address indexed user, uint256 reward);
+}
+
 interface MasterChef {
     function deposit(uint, uint) external;
     function withdraw(uint, uint) external;
@@ -681,7 +990,7 @@ contract GaugeProxy is ProtocolGovernance {
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, _reward);
-                    Gauge(_gauge).notifyRewardAmount(_reward);
+                    GaugeV2(_gauge).notifyRewardAmount(_reward);
                 }
             }
         }

From 0c942781d6d49a660e3f60fc1d43354f30f34e1f Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 7 Jun 2022 13:01:16 +0530
Subject: [PATCH 29/55] fix: added Gauge V2 to Gauge proxy v2

---
 src/dill/gauge-proxy-v2.sol | 306 +++++++++++++++++++++++------------
 src/dill/gauge-proxy.sol    | 310 +-----------------------------------
 2 files changed, 208 insertions(+), 408 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 2f7af4bfd..736027ea5 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -241,46 +241,85 @@ abstract contract ReentrancyGuard {
     }
 }
 
-contract Gauge is ReentrancyGuard {
+contract GaugeV2 is ReentrancyGuard {
     using SafeERC20 for IERC20;
-
-    IERC20 public constant PICKLE =
-        IERC20(0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5);
-    IERC20 public constant DILL =
-        IERC20(0xbBCf169eE191A1Ba7371F30A1C344bFC498b29Cf);
-    address public constant TREASURY =
-        address(0x066419EaEf5DE53cc5da0d8702b990c5bc7D1AB3);
+    
+    // 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 MULTIPLIER_PRECISION = 1e18;
 
     IERC20 public immutable TOKEN;
     address public immutable DISTRIBUTION;
     uint256 public constant DURATION = 7 days;
+    
+    // Lock time and multiplier settings
+    uint256 public lock_max_multiplier = uint256(25e17); // E18. 1x = e18
+    uint256 public lock_time_for_max_multiplier = 1 * 365 * 86400; // 1 year
+    uint256 public lock_time_min = 86400; // 1 * 86400  (1 day)
 
+    // Time tracking
     uint256 public periodFinish = 0;
-    uint256 public rewardRate = 0;
     uint256 public lastUpdateTime;
+    
+    // Rewards tracking
+    mapping(address => uint256) public userRewardPerTokenPaid;
+    mapping(address => uint256) public rewards;
     uint256 public rewardPerTokenStored;
+    uint256 public rewardRate = 0;
+    mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
+
+    // Balance tracking
+    uint256 private _totalSupply;
+    uint public derivedSupply;
+    mapping(address => uint256) private _balances;
+    mapping(address => uint256) public derivedBalances;
+    mapping(address => uint) private _base;
+
+    // Stake tracking 
+    mapping(address => LockedStake[]) private lockedStakes;
+
+    /* ========== STRUCTS ========== */
+
+    struct LockedStake {
+        bytes32 kek_id;
+        uint256 start_timestamp;
+        uint256 liquidity;
+        uint256 ending_timestamp;
+        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+    }
+
+    /* ========== MODIFIERS ========== */
 
     modifier onlyDistribution() {
-        require(
-            msg.sender == DISTRIBUTION,
-            "Caller is not RewardsDistribution contract"
-        );
+        require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
         _;
     }
 
-    mapping(address => uint256) public userRewardPerTokenPaid;
-    mapping(address => uint256) public rewards;
+    modifier updateReward(address account) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateTime = lastTimeRewardApplicable();
+        if (account != address(0)) {
+            rewards[account] = earned(account);
+            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+        }
+        _;
+        if (account != address(0)) {
+            kick(account);
+        }
+    }
 
-    uint256 private _totalSupply;
-    uint256 public derivedSupply;
-    mapping(address => uint256) private _balances;
-    mapping(address => uint256) public derivedBalances;
-    mapping(address => uint256) private _base;
+    /* ========== CONSTRUCTOR ========== */
 
-    constructor(address _token) public {
+    constructor(address _token) {
         TOKEN = IERC20(_token);
         DISTRIBUTION = msg.sender;
     }
+    
+    /* ========== VIEWS ========== */
 
     function totalSupply() external view returns (uint256) {
         return _totalSupply;
@@ -299,81 +338,163 @@ contract Gauge is ReentrancyGuard {
             return rewardPerTokenStored;
         }
         return
-            rewardPerTokenStored +
-            (((lastTimeRewardApplicable() - (lastUpdateTime)) *
-                (rewardRate) *
-                (1e18)) / (derivedSupply));
+            rewardPerTokenStored + (
+                (lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18 / derivedSupply
+            );
     }
 
     function derivedBalance(address account) public view returns (uint256) {
         uint256 _balance = _balances[account];
-        uint256 _derived = (_balance * (40)) / (100);
-        uint256 _adjusted = (((_totalSupply * (DILL.balanceOf(account))) /
-            (DILL.totalSupply())) * (60)) / (100);
-        return Math.min(_derived + (_adjusted), _balance);
-    }
+        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;
+
+            // If the lock is expired
+            if (thisStake.ending_timestamp <= block.timestamp) {
+                // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
+                if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
+                    uint256 time_before_expiry = thisStake.ending_timestamp - lastRewardClaimTime[account];
+                    uint256 time_after_expiry = block.timestamp - thisStake.ending_timestamp;
+
+                    // Get the weighted-average lock_multiplier
+                    uint256 numerator = (lock_multiplier * time_before_expiry) + (MULTIPLIER_PRECISION * time_after_expiry);
+                    lock_multiplier = numerator / (time_before_expiry + time_after_expiry);
+                }
+                // Otherwise, it needs to just be 1x
+                else {
+                    lock_multiplier = MULTIPLIER_PRECISION;
+                }
+            }
 
-    function kick(address account) public {
-        uint256 _derivedBalance = derivedBalances[account];
-        derivedSupply -= (_derivedBalance);
-        _derivedBalance = derivedBalance(account);
-        derivedBalances[account] = _derivedBalance;
-        derivedSupply += (_derivedBalance);
-    }
+            uint256 liquidity = thisStake.liquidity;
+            uint256 combined_boosted_amount = liquidity * lock_multiplier / MULTIPLIER_PRECISION;
+            lockBoostedDerivedBal = lockBoostedDerivedBal + combined_boosted_amount;
+        }
 
-    function earned(address account) public view returns (uint256) {
-        return
-            ((derivedBalances[account] *
-                (rewardPerToken() - (userRewardPerTokenPaid[account]))) /
-                (1e18)) + (rewards[account]);
+        return dillBoostedDerivedBal + lockBoostedDerivedBal;
     }
 
-    function getRewardForDuration() external view returns (uint256) {
-        return rewardRate * (DURATION);
+    // All the locked stakes for a given account
+    function lockedStakesOf(address account) external view returns (LockedStake[] memory) {
+        return lockedStakes[account];
     }
 
-    function depositAll() external {
-        _deposit(TOKEN.balanceOf(msg.sender), msg.sender);
+    function earned(address account) public view returns (uint256) {
+        return (derivedBalances[account] * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18) + rewards[account];
     }
 
-    function deposit(uint256 amount) external {
-        _deposit(amount, msg.sender);
+    function getRewardForDuration() external view returns (uint256) {
+        return rewardRate * DURATION;
     }
 
-    function depositFor(uint256 amount, address account) external {
-        _deposit(amount, account);
+    // Multiplier amount, given the length of the lock
+    function lockMultiplier(uint256 secs) public view returns (uint256) {
+        uint256 lock_multiplier =
+            uint256(MULTIPLIER_PRECISION) + (
+                secs * (lock_max_multiplier - MULTIPLIER_PRECISION) / (lock_time_for_max_multiplier)
+            );
+        if (lock_multiplier > lock_max_multiplier) lock_multiplier = lock_max_multiplier;
+        return lock_multiplier;
     }
+    
+    /* ========== MUTATIVE FUNCTIONS ========== */
 
-    function _deposit(uint256 amount, address account)
-        internal
-        nonReentrant
-        updateReward(account)
-    {
+    function kick(address account) public {
+        uint _derivedBalance = derivedBalances[account];
+        derivedSupply = derivedSupply - _derivedBalance;
+        _derivedBalance = derivedBalance(account);
+        derivedBalances[account] = _derivedBalance;
+        derivedSupply = derivedSupply + _derivedBalance;
+    }
+    
+    function depositAll(uint256 secs) external {
+        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, secs, block.timestamp);
+    }
+    
+    function deposit(uint256 amount, uint256 secs) external {
+        _deposit(amount, msg.sender, secs, block.timestamp);
+    }
+    
+    function depositFor(uint256 amount, address account, uint256 secs) external {
+        _deposit(amount, account, secs, block.timestamp);
+    }
+    
+    function _deposit(
+        uint amount,
+        address account,
+        uint256 secs,
+        uint256 start_timestamp
+    ) internal nonReentrant updateReward(account) {
         require(amount > 0, "Cannot stake 0");
-        _totalSupply += (amount);
-        _balances[account] += (amount);
-        emit Staked(account, amount);
+        uint256 lock_multiplier = lockMultiplier(secs);
+        bytes32 kek_id = keccak256(abi.encodePacked(account, start_timestamp, amount, _balances[account]));
+        lockedStakes[account].push(LockedStake(
+            kek_id,
+            start_timestamp,
+            amount,
+            start_timestamp + secs,
+            lock_multiplier
+        ));
+
         TOKEN.safeTransferFrom(account, address(this), amount);
+
+        _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;
+
+        emit Staked(account, amount, secs, kek_id);
     }
 
-    function withdrawAll() external {
-        _withdraw(_balances[msg.sender]);
+    function withdraw(bytes32 kek_id) external {
+        _withdraw(kek_id);
     }
 
-    function withdraw(uint256 amount) external {
-        _withdraw(amount);
+    function withdrawAll() public nonReentrant updateReward(msg.sender) {
+        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
+            uint256 liquidity = lockedStakes[msg.sender][i].liquidity;
+            if (liquidity > 0){
+                _totalSupply = _totalSupply - liquidity;
+                _balances[msg.sender] = _balances[msg.sender] - liquidity;
+                delete lockedStakes[msg.sender][i];
+                TOKEN.safeTransfer(msg.sender, liquidity);
+                emit Withdrawn(msg.sender, liquidity, lockedStakes[msg.sender][i].kek_id);
+            }
+        }
     }
+    
+    function _withdraw(bytes32 kek_id) internal nonReentrant updateReward(msg.sender) {
+        LockedStake memory thisStake;
+        thisStake.liquidity = 0;
+        uint theArrayIndex;
+        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
+            if (kek_id == lockedStakes[msg.sender][i].kek_id){
+                thisStake = lockedStakes[msg.sender][i];
+                theArrayIndex = i;
+                break;
+            }
+        }
 
-    function _withdraw(uint256 amount)
-        internal
-        nonReentrant
-        updateReward(msg.sender)
-    {
-        require(amount > 0, "Cannot withdraw 0");
-        _totalSupply -= (amount);
-        _balances[msg.sender] -= (amount);
-        TOKEN.safeTransfer(msg.sender, amount);
-        emit Withdrawn(msg.sender, amount);
+        require(thisStake.kek_id == kek_id, "Stake not found");
+        require(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][theArrayIndex];
+            TOKEN.safeTransfer(msg.sender, liquidity);
+        }
+
+        emit Withdrawn(msg.sender, liquidity, kek_id);
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
@@ -386,21 +507,19 @@ contract Gauge is ReentrancyGuard {
     }
 
     function exit() external {
-        _withdraw(_balances[msg.sender]);
+        withdrawAll();
         getReward();
     }
+    
+    /* ========== RESTRICTED FUNCTIONS ========== */
 
-    function notifyRewardAmount(uint256 reward)
-        external
-        onlyDistribution
-        updateReward(address(0))
-    {
+    function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
         PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
         if (block.timestamp >= periodFinish) {
-            rewardRate = reward / (DURATION);
+            rewardRate = reward / DURATION;
         } else {
-            uint256 remaining = periodFinish - (block.timestamp);
-            uint256 leftover = remaining * (rewardRate);
+            uint256 remaining = periodFinish - block.timestamp;
+            uint256 leftover = remaining * rewardRate;
             rewardRate = (reward + leftover) / DURATION;
         }
 
@@ -408,30 +527,19 @@ contract Gauge is ReentrancyGuard {
         // 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 = PICKLE.balanceOf(address(this));
-        require(rewardRate <= balance / (DURATION), "Provided reward too high");
+        uint balance = PICKLE.balanceOf(address(this));
+        require(rewardRate <= balance / DURATION, "Provided reward too high");
 
         lastUpdateTime = block.timestamp;
         periodFinish = block.timestamp + DURATION;
         emit RewardAdded(reward);
     }
 
-    modifier updateReward(address account) {
-        rewardPerTokenStored = rewardPerToken();
-        lastUpdateTime = lastTimeRewardApplicable();
-        if (account != address(0)) {
-            rewards[account] = earned(account);
-            userRewardPerTokenPaid[account] = rewardPerTokenStored;
-        }
-        _;
-        if (account != address(0)) {
-            kick(account);
-        }
-    }
+    /* ========== EVENTS ========== */
 
     event RewardAdded(uint256 reward);
-    event Staked(address indexed user, uint256 amount);
-    event Withdrawn(address indexed user, uint256 amount);
+    event Staked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id);
+    event Withdrawn(address indexed user, uint256 amount, bytes32 kek_id);
     event RewardPaid(address indexed user, uint256 reward);
 }
 
@@ -934,7 +1042,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function addGauge(address _token) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
-        gauges[_token] = address(new Gauge(_token));
+        gauges[_token] = address(new GaugeV2(_token));
         _tokens.push(_token);
     }
 
@@ -1036,7 +1144,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, uint256(_reward));
-                    Gauge(_gauge).notifyRewardAmount(uint256(_reward));
+                    GaugeV2(_gauge).notifyRewardAmount(uint256(_reward));
                 }
 
                 if (_reward < 0) {
diff --git a/src/dill/gauge-proxy.sol b/src/dill/gauge-proxy.sol
index c74f51eb4..8064a5d4f 100644
--- a/src/dill/gauge-proxy.sol
+++ b/src/dill/gauge-proxy.sol
@@ -385,314 +385,6 @@ contract Gauge is ReentrancyGuard {
     event RewardPaid(address indexed user, uint256 reward);
 }
 
-contract GaugeV2 is ReentrancyGuard {
-    using SafeMath for uint256;
-    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 MULTIPLIER_PRECISION = 1e18;
-
-    IERC20 public immutable TOKEN;
-    address public immutable DISTRIBUTION;
-    uint256 public constant DURATION = 7 days;
-    
-    // Lock time and multiplier settings
-    uint256 public lock_max_multiplier = uint256(25e17); // E18. 1x = e18
-    uint256 public lock_time_for_max_multiplier = 1 * 365 * 86400; // 1 year
-    uint256 public lock_time_min = 86400; // 1 * 86400  (1 day)
-
-    // Time tracking
-    uint256 public periodFinish = 0;
-    uint256 public lastUpdateTime;
-    
-    // Rewards tracking
-    mapping(address => uint256) public userRewardPerTokenPaid;
-    mapping(address => uint256) public rewards;
-    uint256 public rewardPerTokenStored;
-    uint256 public rewardRate = 0;
-    mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
-
-    // Balance tracking
-    uint256 private _totalSupply;
-    uint public derivedSupply;
-    mapping(address => uint256) private _balances;
-    mapping(address => uint256) public derivedBalances;
-    mapping(address => uint) private _base;
-
-    // Stake tracking 
-    mapping(address => LockedStake[]) private lockedStakes;
-
-    /* ========== STRUCTS ========== */
-
-    struct LockedStake {
-        bytes32 kek_id;
-        uint256 start_timestamp;
-        uint256 liquidity;
-        uint256 ending_timestamp;
-        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
-    }
-
-    /* ========== MODIFIERS ========== */
-
-    modifier onlyDistribution() {
-        require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
-        _;
-    }
-
-    modifier updateReward(address account) {
-        rewardPerTokenStored = rewardPerToken();
-        lastUpdateTime = lastTimeRewardApplicable();
-        if (account != address(0)) {
-            rewards[account] = earned(account);
-            userRewardPerTokenPaid[account] = rewardPerTokenStored;
-        }
-        _;
-        if (account != address(0)) {
-            kick(account);
-        }
-    }
-
-    /* ========== CONSTRUCTOR ========== */
-
-    constructor(address _token) public {
-        TOKEN = IERC20(_token);
-        DISTRIBUTION = msg.sender;
-    }
-    
-    /* ========== 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) {
-        if (_totalSupply == 0) {
-            return rewardPerTokenStored;
-        }
-        return
-            rewardPerTokenStored.add(
-                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(derivedSupply)
-            );
-    }
-
-    function derivedBalance(address account) public view returns (uint256) {
-        uint256 _balance = _balances[account];
-        uint256 _derived = _balance.mul(40).div(100);
-        uint256 _adjusted = (_totalSupply.mul(DILL.balanceOf(account)).div(DILL.totalSupply())).mul(60).div(100);
-        uint256 dillBoostedDerivedBal = Math.min(_derived.add(_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;
-
-            // If the lock is expired
-            if (thisStake.ending_timestamp <= block.timestamp) {
-                // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
-                if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
-                    uint256 time_before_expiry = (thisStake.ending_timestamp).sub(lastRewardClaimTime[account]);
-                    uint256 time_after_expiry = (block.timestamp).sub(thisStake.ending_timestamp);
-
-                    // Get the weighted-average lock_multiplier
-                    uint256 numerator = ((lock_multiplier).mul(time_before_expiry)).add(((MULTIPLIER_PRECISION).mul(time_after_expiry)));
-                    lock_multiplier = numerator.div(time_before_expiry.add(time_after_expiry));
-                }
-                // Otherwise, it needs to just be 1x
-                else {
-                    lock_multiplier = MULTIPLIER_PRECISION;
-                }
-            }
-
-            uint256 liquidity = thisStake.liquidity;
-            uint256 combined_boosted_amount = liquidity.mul(lock_multiplier).div(MULTIPLIER_PRECISION);
-            lockBoostedDerivedBal = lockBoostedDerivedBal.add(combined_boosted_amount);
-        }
-
-        return dillBoostedDerivedBal.add(lockBoostedDerivedBal);
-    }
-
-    // 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) {
-        return derivedBalances[account]
-            .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
-            .div(1e18)
-            .add(rewards[account]);
-    }
-
-    function getRewardForDuration() external view returns (uint256) {
-        return rewardRate.mul(DURATION);
-    }
-
-    // Multiplier amount, given the length of the lock
-    function lockMultiplier(uint256 secs) public view returns (uint256) {
-        uint256 lock_multiplier =
-            uint256(MULTIPLIER_PRECISION).add(
-                secs
-                    .mul(lock_max_multiplier.sub(MULTIPLIER_PRECISION))
-                    .div(lock_time_for_max_multiplier)
-            );
-        if (lock_multiplier > lock_max_multiplier) lock_multiplier = lock_max_multiplier;
-        return lock_multiplier;
-    }
-    
-    /* ========== MUTATIVE FUNCTIONS ========== */
-
-    function kick(address account) public {
-        uint _derivedBalance = derivedBalances[account];
-        derivedSupply = derivedSupply.sub(_derivedBalance);
-        _derivedBalance = derivedBalance(account);
-        derivedBalances[account] = _derivedBalance;
-        derivedSupply = derivedSupply.add(_derivedBalance);
-    }
-    
-    function depositAll(uint256 secs) external {
-        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, secs, block.timestamp);
-    }
-    
-    function deposit(uint256 amount, uint256 secs) external {
-        _deposit(amount, msg.sender, secs, block.timestamp);
-    }
-    
-    function depositFor(uint256 amount, address account, uint256 secs) external {
-        _deposit(amount, account, secs, block.timestamp);
-    }
-    
-    function _deposit(
-        uint amount,
-        address account,
-        uint256 secs,
-        uint256 start_timestamp
-    ) internal nonReentrant updateReward(account) {
-        require(amount > 0, "Cannot stake 0");
-        uint256 lock_multiplier = lockMultiplier(secs);
-        bytes32 kek_id = keccak256(abi.encodePacked(account, start_timestamp, amount, _balances[account]));
-        lockedStakes[account].push(LockedStake(
-            kek_id,
-            start_timestamp,
-            amount,
-            start_timestamp.add(secs),
-            lock_multiplier
-        ));
-
-        TOKEN.safeTransferFrom(account, address(this), amount);
-
-        _totalSupply = _totalSupply.add(amount);
-        _balances[account] = _balances[account].add(amount);
-
-        // 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, kek_id);
-    }
-
-    function withdraw(bytes32 kek_id) external {
-        _withdraw(kek_id);
-    }
-
-    function withdrawAll() public nonReentrant updateReward(msg.sender) {
-        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
-            uint256 liquidity = lockedStakes[msg.sender][i].liquidity;
-            if (liquidity > 0){
-                _totalSupply = _totalSupply.sub(liquidity);
-                _balances[msg.sender] = _balances[msg.sender].sub(liquidity);
-                delete lockedStakes[msg.sender][i];
-                TOKEN.safeTransfer(msg.sender, liquidity);
-                emit Withdrawn(msg.sender, liquidity, lockedStakes[msg.sender][i].kek_id);
-            }
-        }
-    }
-    
-    function _withdraw(bytes32 kek_id) internal nonReentrant updateReward(msg.sender) {
-        LockedStake memory thisStake;
-        thisStake.liquidity = 0;
-        uint theArrayIndex;
-        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
-            if (kek_id == lockedStakes[msg.sender][i].kek_id){
-                thisStake = lockedStakes[msg.sender][i];
-                theArrayIndex = i;
-                break;
-            }
-        }
-
-        require(thisStake.kek_id == kek_id, "Stake not found");
-        require(block.timestamp >= thisStake.ending_timestamp, "Stake is still locked!");
-
-        uint256 liquidity = thisStake.liquidity;
-
-        if (liquidity > 0) {
-            _totalSupply = _totalSupply.sub(liquidity);
-            _balances[msg.sender] = _balances[msg.sender].sub(liquidity);
-            delete lockedStakes[msg.sender][theArrayIndex];
-            TOKEN.safeTransfer(msg.sender, liquidity);
-        }
-
-        emit Withdrawn(msg.sender, liquidity, kek_id);
-    }
-
-    function getReward() public nonReentrant updateReward(msg.sender) {
-        uint256 reward = rewards[msg.sender];
-        if (reward > 0) {
-            rewards[msg.sender] = 0;
-            PICKLE.safeTransfer(msg.sender, reward);
-            emit RewardPaid(msg.sender, reward);
-        }
-    }
-
-    function exit() external {
-        withdrawAll();
-        getReward();
-    }
-    
-    /* ========== RESTRICTED FUNCTIONS ========== */
-
-    function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
-        PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
-        if (block.timestamp >= periodFinish) {
-            rewardRate = reward.div(DURATION);
-        } else {
-            uint256 remaining = periodFinish.sub(block.timestamp);
-            uint256 leftover = remaining.mul(rewardRate);
-            rewardRate = reward.add(leftover).div(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.
-        uint balance = PICKLE.balanceOf(address(this));
-        require(rewardRate <= balance.div(DURATION), "Provided reward too high");
-
-        lastUpdateTime = block.timestamp;
-        periodFinish = block.timestamp.add(DURATION);
-        emit RewardAdded(reward);
-    }
-
-    /* ========== EVENTS ========== */
-
-    event RewardAdded(uint256 reward);
-    event Staked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id);
-    event Withdrawn(address indexed user, uint256 amount, bytes32 kek_id);
-    event RewardPaid(address indexed user, uint256 reward);
-}
-
 interface MasterChef {
     function deposit(uint, uint) external;
     function withdraw(uint, uint) external;
@@ -990,7 +682,7 @@ contract GaugeProxy is ProtocolGovernance {
                 if (_reward > 0) {
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, _reward);
-                    GaugeV2(_gauge).notifyRewardAmount(_reward);
+                    Gauge(_gauge).notifyRewardAmount(_reward);
                 }
             }
         }

From e12911d5e98ef648187952d748ad626d2d63e1d9 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 7 Jun 2022 17:26:57 +0530
Subject: [PATCH 30/55] feat: add setters and minor improvements

---
 src/dill/gauge-proxy-v2.sol | 318 ++++++++++++++++++++++++------------
 1 file changed, 212 insertions(+), 106 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 736027ea5..ff63fcc11 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -241,21 +241,50 @@ abstract contract ReentrancyGuard {
     }
 }
 
-contract GaugeV2 is ReentrancyGuard {
+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;
+    }
+}
+
+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);
-    
+    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 MULTIPLIER_PRECISION = 1e18;
 
     IERC20 public immutable TOKEN;
     address public immutable DISTRIBUTION;
     uint256 public constant DURATION = 7 days;
-    
+
     // Lock time and multiplier settings
     uint256 public lock_max_multiplier = uint256(25e17); // E18. 1x = e18
     uint256 public lock_time_for_max_multiplier = 1 * 365 * 86400; // 1 year
@@ -264,7 +293,7 @@ contract GaugeV2 is ReentrancyGuard {
     // Time tracking
     uint256 public periodFinish = 0;
     uint256 public lastUpdateTime;
-    
+
     // Rewards tracking
     mapping(address => uint256) public userRewardPerTokenPaid;
     mapping(address => uint256) public rewards;
@@ -274,18 +303,17 @@ contract GaugeV2 is ReentrancyGuard {
 
     // Balance tracking
     uint256 private _totalSupply;
-    uint public derivedSupply;
+    uint256 public derivedSupply;
     mapping(address => uint256) private _balances;
     mapping(address => uint256) public derivedBalances;
-    mapping(address => uint) private _base;
+    mapping(address => uint256) private _base;
 
-    // Stake tracking 
+    // Stake tracking
     mapping(address => LockedStake[]) private lockedStakes;
 
     /* ========== STRUCTS ========== */
 
     struct LockedStake {
-        bytes32 kek_id;
         uint256 start_timestamp;
         uint256 liquidity;
         uint256 ending_timestamp;
@@ -295,7 +323,27 @@ contract GaugeV2 is ReentrancyGuard {
     /* ========== MODIFIERS ========== */
 
     modifier onlyDistribution() {
-        require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
+        require(
+            msg.sender == DISTRIBUTION,
+            "Caller is not RewardsDistribution contract"
+        );
+        _;
+    }
+
+    modifier onlyGov() {
+        require(
+            msg.sender == governance,
+            "Caller is not RewardsDistribution contract"
+        );
+        _;
+    }
+
+    modifier lockable(uint256 secs) {
+        require(secs >= lock_time_min, "Minimum stake time not met");
+        require(
+            secs <= lock_time_for_max_multiplier,
+            "Trying to lock for too long"
+        );
         _;
     }
 
@@ -318,7 +366,7 @@ contract GaugeV2 is ReentrancyGuard {
         TOKEN = IERC20(_token);
         DISTRIBUTION = msg.sender;
     }
-    
+
     /* ========== VIEWS ========== */
 
     function totalSupply() external view returns (uint256) {
@@ -338,16 +386,21 @@ contract GaugeV2 is ReentrancyGuard {
             return rewardPerTokenStored;
         }
         return
-            rewardPerTokenStored + (
-                (lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18 / derivedSupply
-            );
+            rewardPerTokenStored +
+            (((lastTimeRewardApplicable() - lastUpdateTime) *
+                rewardRate *
+                1e18) / derivedSupply);
     }
 
     function derivedBalance(address account) public view 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);
+        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;
@@ -358,13 +411,18 @@ contract GaugeV2 is ReentrancyGuard {
             // If the lock is expired
             if (thisStake.ending_timestamp <= block.timestamp) {
                 // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
-                if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
-                    uint256 time_before_expiry = thisStake.ending_timestamp - lastRewardClaimTime[account];
-                    uint256 time_after_expiry = block.timestamp - thisStake.ending_timestamp;
+                if (lastRewardClaimTime[account] < thisStake.ending_timestamp) {
+                    uint256 time_before_expiry = thisStake.ending_timestamp -
+                        lastRewardClaimTime[account];
+                    uint256 time_after_expiry = block.timestamp -
+                        thisStake.ending_timestamp;
 
                     // Get the weighted-average lock_multiplier
-                    uint256 numerator = (lock_multiplier * time_before_expiry) + (MULTIPLIER_PRECISION * time_after_expiry);
-                    lock_multiplier = numerator / (time_before_expiry + time_after_expiry);
+                    uint256 numerator = (lock_multiplier * time_before_expiry) +
+                        (MULTIPLIER_PRECISION * time_after_expiry);
+                    lock_multiplier =
+                        numerator /
+                        (time_before_expiry + time_after_expiry);
                 }
                 // Otherwise, it needs to just be 1x
                 else {
@@ -373,20 +431,30 @@ contract GaugeV2 is ReentrancyGuard {
             }
 
             uint256 liquidity = thisStake.liquidity;
-            uint256 combined_boosted_amount = liquidity * lock_multiplier / MULTIPLIER_PRECISION;
-            lockBoostedDerivedBal = lockBoostedDerivedBal + combined_boosted_amount;
+            uint256 combined_boosted_amount = (liquidity * lock_multiplier) /
+                MULTIPLIER_PRECISION;
+            lockBoostedDerivedBal =
+                lockBoostedDerivedBal +
+                combined_boosted_amount;
         }
 
         return dillBoostedDerivedBal + lockBoostedDerivedBal;
     }
 
     // All the locked stakes for a given account
-    function lockedStakesOf(address account) external view returns (LockedStake[] memory) {
+    function lockedStakesOf(address account)
+        external
+        view
+        returns (LockedStake[] memory)
+    {
         return lockedStakes[account];
     }
 
     function earned(address account) public view returns (uint256) {
-        return (derivedBalances[account] * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18) + rewards[account];
+        return
+            ((derivedBalances[account] *
+                (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
+            rewards[account];
     }
 
     function getRewardForDuration() external view returns (uint256) {
@@ -395,52 +463,76 @@ contract GaugeV2 is ReentrancyGuard {
 
     // Multiplier amount, given the length of the lock
     function lockMultiplier(uint256 secs) public view returns (uint256) {
-        uint256 lock_multiplier =
-            uint256(MULTIPLIER_PRECISION) + (
-                secs * (lock_max_multiplier - MULTIPLIER_PRECISION) / (lock_time_for_max_multiplier)
-            );
-        if (lock_multiplier > lock_max_multiplier) lock_multiplier = lock_max_multiplier;
+        uint256 lock_multiplier = uint256(MULTIPLIER_PRECISION) +
+            ((secs * (lock_max_multiplier - MULTIPLIER_PRECISION)) /
+                (lock_time_for_max_multiplier));
+        if (lock_multiplier > lock_max_multiplier)
+            lock_multiplier = lock_max_multiplier;
         return lock_multiplier;
     }
-    
+
     /* ========== MUTATIVE FUNCTIONS ========== */
 
     function kick(address account) public {
-        uint _derivedBalance = derivedBalances[account];
+        uint256 _derivedBalance = derivedBalances[account];
         derivedSupply = derivedSupply - _derivedBalance;
         _derivedBalance = derivedBalance(account);
         derivedBalances[account] = _derivedBalance;
         derivedSupply = derivedSupply + _derivedBalance;
     }
-    
-    function depositAll(uint256 secs) external {
-        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, secs, block.timestamp);
+
+    function depositAllAndLock(uint256 secs) external lockable(secs) {
+        _deposit(
+            TOKEN.balanceOf(msg.sender),
+            msg.sender,
+            secs,
+            block.timestamp
+        );
     }
-    
-    function deposit(uint256 amount, uint256 secs) external {
-        _deposit(amount, msg.sender, secs, block.timestamp);
+
+    function depositAll() external {
+        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, 0, block.timestamp);
     }
-    
-    function depositFor(uint256 amount, address account, uint256 secs) external {
+
+    function depositFor(uint256 amount, address account) external {
+        _deposit(amount, account, 0, block.timestamp);
+    }
+
+    function depositForAndLock(
+        uint256 amount,
+        address account,
+        uint256 secs
+    ) external lockable(secs) {
         _deposit(amount, account, secs, block.timestamp);
     }
-    
+
+    function deposit(uint256 amount) external {
+        _deposit(amount, msg.sender, 0, block.timestamp);
+    }
+
+    function depositAndLock(uint256 amount, uint256 secs)
+        external
+        lockable(secs)
+    {
+        _deposit(amount, msg.sender, secs, block.timestamp);
+    }
+
     function _deposit(
-        uint amount,
+        uint256 amount,
         address account,
         uint256 secs,
         uint256 start_timestamp
     ) internal nonReentrant updateReward(account) {
         require(amount > 0, "Cannot stake 0");
         uint256 lock_multiplier = lockMultiplier(secs);
-        bytes32 kek_id = keccak256(abi.encodePacked(account, start_timestamp, amount, _balances[account]));
-        lockedStakes[account].push(LockedStake(
-            kek_id,
-            start_timestamp,
-            amount,
-            start_timestamp + secs,
-            lock_multiplier
-        ));
+        lockedStakes[account].push(
+            LockedStake(
+                start_timestamp,
+                amount,
+                start_timestamp + secs,
+                lock_multiplier
+            )
+        );
 
         TOKEN.safeTransferFrom(account, address(this), amount);
 
@@ -448,53 +540,55 @@ contract GaugeV2 is ReentrancyGuard {
         _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;
+        if (lastRewardClaimTime[account] == 0)
+            lastRewardClaimTime[account] = block.timestamp;
 
-        emit Staked(account, amount, secs, kek_id);
+        emit Staked(account, amount, secs, lockedStakes[account].length - 1);
     }
 
-    function withdraw(bytes32 kek_id) external {
-        _withdraw(kek_id);
+    function withdraw(uint256 index) external {
+        _withdraw(index);
     }
 
     function withdrawAll() public nonReentrant updateReward(msg.sender) {
-        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
+        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++) {
             uint256 liquidity = lockedStakes[msg.sender][i].liquidity;
-            if (liquidity > 0){
+            if (liquidity > 0) {
                 _totalSupply = _totalSupply - liquidity;
                 _balances[msg.sender] = _balances[msg.sender] - liquidity;
                 delete lockedStakes[msg.sender][i];
                 TOKEN.safeTransfer(msg.sender, liquidity);
-                emit Withdrawn(msg.sender, liquidity, lockedStakes[msg.sender][i].kek_id);
+                emit Withdrawn(msg.sender, liquidity, i);
             }
         }
     }
-    
-    function _withdraw(bytes32 kek_id) internal nonReentrant updateReward(msg.sender) {
+
+    function _withdraw(uint256 index)
+        internal
+        nonReentrant
+        updateReward(msg.sender)
+    {
         LockedStake memory thisStake;
         thisStake.liquidity = 0;
-        uint theArrayIndex;
-        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++){ 
-            if (kek_id == lockedStakes[msg.sender][i].kek_id){
-                thisStake = lockedStakes[msg.sender][i];
-                theArrayIndex = i;
-                break;
-            }
-        }
+        require(index < lockedStakes[msg.sender].length, "Stake not found");
 
-        require(thisStake.kek_id == kek_id, "Stake not found");
-        require(block.timestamp >= thisStake.ending_timestamp, "Stake is still locked!");
+        thisStake = lockedStakes[msg.sender][index];
+
+        require(
+            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][theArrayIndex];
+            delete lockedStakes[msg.sender][index];
             TOKEN.safeTransfer(msg.sender, liquidity);
         }
 
-        emit Withdrawn(msg.sender, liquidity, kek_id);
+        emit Withdrawn(msg.sender, liquidity, index);
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
@@ -504,16 +598,22 @@ contract GaugeV2 is ReentrancyGuard {
             PICKLE.safeTransfer(msg.sender, reward);
             emit RewardPaid(msg.sender, reward);
         }
+
+        lastRewardClaimTime[msg.sender] = block.timestamp;
     }
 
     function exit() external {
         withdrawAll();
         getReward();
     }
-    
+
     /* ========== RESTRICTED FUNCTIONS ========== */
 
-    function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
+    function notifyRewardAmount(uint256 reward)
+        external
+        onlyDistribution
+        updateReward(address(0))
+    {
         PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
         if (block.timestamp >= periodFinish) {
             rewardRate = reward / DURATION;
@@ -527,7 +627,7 @@ contract GaugeV2 is ReentrancyGuard {
         // 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.
-        uint balance = PICKLE.balanceOf(address(this));
+        uint256 balance = PICKLE.balanceOf(address(this));
         require(rewardRate <= balance / DURATION, "Provided reward too high");
 
         lastUpdateTime = block.timestamp;
@@ -535,12 +635,44 @@ contract GaugeV2 is ReentrancyGuard {
         emit RewardAdded(reward);
     }
 
+    function setMultipliers(uint256 _lock_max_multiplier) external onlyGov {
+        require(
+            _lock_max_multiplier >= uint256(1e18),
+            "Multiplier must be greater than or equal to 1e18"
+        );
+        lock_max_multiplier = _lock_max_multiplier;
+        emit LockedStakeMaxMultiplierUpdated(lock_max_multiplier);
+    }
+
+    function setMaxRewardsDuration(uint256 _lock_time_for_max_multiplier)
+        external
+        onlyGov
+    {
+        require(
+            _lock_time_for_max_multiplier >= 86400,
+            "Rewards duration too short"
+        );
+        require(
+            periodFinish == 0 || block.timestamp > periodFinish,
+            "Reward period incomplete"
+        );
+        lock_time_for_max_multiplier = _lock_time_for_max_multiplier;
+        emit MaxRewardsDurationUpdated(lock_time_for_max_multiplier);
+    }
+
     /* ========== EVENTS ========== */
 
     event RewardAdded(uint256 reward);
-    event Staked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id);
-    event Withdrawn(address indexed user, uint256 amount, bytes32 kek_id);
+    event Staked(
+        address indexed user,
+        uint256 amount,
+        uint256 secs,
+        uint256 index
+    );
+    event Withdrawn(address indexed user, uint256 amount, uint256 index);
     event RewardPaid(address indexed user, uint256 reward);
+    event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
+    event MaxRewardsDurationUpdated(uint256 newDuration);
 }
 
 interface MasterChef {
@@ -554,32 +686,6 @@ interface MasterChef {
         returns (uint256, uint256);
 }
 
-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;
-    }
-}
-
 contract MasterDill {
     /// @notice EIP-20 token name for this token
     string public constant name = "Master DILL";

From d07c2e8b499ea944215f5404eb4cbcfa204ac0fb Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 8 Jun 2022 11:15:34 +0530
Subject: [PATCH 31/55] feat: add more admin functions

---
 src/dill/gauge-proxy-v2.sol | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index ff63fcc11..2d9722a25 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -311,6 +311,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     // 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 {
@@ -362,9 +366,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     /* ========== CONSTRUCTOR ========== */
 
-    constructor(address _token) {
+    constructor(address _token, address _governance) {
         TOKEN = IERC20(_token);
         DISTRIBUTION = msg.sender;
+        governance = _governance;
     }
 
     /* ========== VIEWS ========== */
@@ -575,7 +580,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         thisStake = lockedStakes[msg.sender][index];
 
         require(
-            block.timestamp >= thisStake.ending_timestamp,
+            block.timestamp >= thisStake.ending_timestamp 
+                || stakesUnlocked == true
+                || stakesUnlockedForAccount[msg.sender] == true,
             "Stake is still locked!"
         );
 
@@ -660,6 +667,14 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         emit MaxRewardsDurationUpdated(lock_time_for_max_multiplier);
     }
 
+    function unlockStakes() external onlyGov {
+        stakesUnlocked = !stakesUnlocked;
+    }
+
+    function unlockStakeForAccount(address account) external onlyGov {
+        stakesUnlockedForAccount[account] = !stakesUnlockedForAccount[account];
+    }
+
     /* ========== EVENTS ========== */
 
     event RewardAdded(uint256 reward);
@@ -1148,7 +1163,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function addGauge(address _token) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
-        gauges[_token] = address(new GaugeV2(_token));
+        gauges[_token] = address(new GaugeV2(_token, governance));
         _tokens.push(_token);
     }
 

From aab7a805608d0e50b863ce1f301dd8c2aab07a11 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 9 Jun 2022 16:16:40 +0530
Subject: [PATCH 32/55] feat: add decaying reward multiplier logic

---
 src/dill/gauge-proxy-v2.sol | 96 +++++++++++++++++++++++--------------
 1 file changed, 59 insertions(+), 37 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 2d9722a25..e74d49d0b 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -299,6 +299,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     mapping(address => uint256) public rewards;
     uint256 public rewardPerTokenStored;
     uint256 public rewardRate = 0;
+    uint256 public multiplierDecayPerPeriod = uint256(2876712e10);
+    mapping(address => uint256) private lastusedMultiplier;
     mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
 
     // Balance tracking
@@ -337,7 +339,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     modifier onlyGov() {
         require(
             msg.sender == governance,
-            "Caller is not RewardsDistribution contract"
+            "Operation allowed by only governance"
         );
         _;
     }
@@ -397,7 +399,48 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 1e18) / derivedSupply);
     }
 
-    function derivedBalance(address account) public view returns (uint256) {
+    // 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) {
+        return
+            ((derivedBalances[account] *
+                (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
+            rewards[account];
+    }
+
+    function getRewardForDuration() external view returns (uint256) {
+        return rewardRate * DURATION;
+    }
+
+    // Multiplier amount, given the length of the lock
+    function lockMultiplier(uint256 secs) public view returns (uint256) {
+        uint256 lock_multiplier = uint256(MULTIPLIER_PRECISION) +
+            ((secs * (lock_max_multiplier - MULTIPLIER_PRECISION)) /
+                (lock_time_for_max_multiplier));
+        if (lock_multiplier > lock_max_multiplier)
+            lock_multiplier = lock_max_multiplier;
+        return lock_multiplier;
+    }
+
+    function _decayedLockMultiplier(address account, uint256 elapsedPeriods)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            (lastusedMultiplier[account] +
+                (elapsedPeriods - 1) *
+                multiplierDecayPerPeriod) / 2;
+    }
+
+    function derivedBalance(address account) public returns (uint256) {
         uint256 _balance = _balances[account];
         uint256 _derived = (_balance * 40) / 100;
         uint256 _adjusted = (((_totalSupply * DILL.balanceOf(account)) /
@@ -433,6 +476,15 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 else {
                     lock_multiplier = MULTIPLIER_PRECISION;
                 }
+            } else {
+                uint256 elapsedPeriods = (block.timestamp - lastUpdateTime) / 7;
+                if (elapsedPeriods > 0) {
+                    lock_multiplier = _decayedLockMultiplier(
+                        account,
+                        elapsedPeriods
+                    );
+                    lastusedMultiplier[account] = lock_multiplier;
+                }
             }
 
             uint256 liquidity = thisStake.liquidity;
@@ -446,36 +498,6 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return dillBoostedDerivedBal + lockBoostedDerivedBal;
     }
 
-    // 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) {
-        return
-            ((derivedBalances[account] *
-                (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
-            rewards[account];
-    }
-
-    function getRewardForDuration() external view returns (uint256) {
-        return rewardRate * DURATION;
-    }
-
-    // Multiplier amount, given the length of the lock
-    function lockMultiplier(uint256 secs) public view returns (uint256) {
-        uint256 lock_multiplier = uint256(MULTIPLIER_PRECISION) +
-            ((secs * (lock_max_multiplier - MULTIPLIER_PRECISION)) /
-                (lock_time_for_max_multiplier));
-        if (lock_multiplier > lock_max_multiplier)
-            lock_multiplier = lock_max_multiplier;
-        return lock_multiplier;
-    }
-
     /* ========== MUTATIVE FUNCTIONS ========== */
 
     function kick(address account) public {
@@ -529,13 +551,13 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 start_timestamp
     ) internal nonReentrant updateReward(account) {
         require(amount > 0, "Cannot stake 0");
-        uint256 lock_multiplier = lockMultiplier(secs);
+        lastusedMultiplier[account] = lockMultiplier(secs);
         lockedStakes[account].push(
             LockedStake(
                 start_timestamp,
                 amount,
                 start_timestamp + secs,
-                lock_multiplier
+                lastusedMultiplier[account]
             )
         );
 
@@ -580,9 +602,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         thisStake = lockedStakes[msg.sender][index];
 
         require(
-            block.timestamp >= thisStake.ending_timestamp 
-                || stakesUnlocked == true
-                || stakesUnlockedForAccount[msg.sender] == true,
+            block.timestamp >= thisStake.ending_timestamp ||
+                stakesUnlocked == true ||
+                stakesUnlockedForAccount[msg.sender] == true,
             "Stake is still locked!"
         );
 

From 51913c2a2efcc5834c726027dc93c7cb0a3765f9 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 9 Jun 2022 17:26:09 +0530
Subject: [PATCH 33/55] fix: chnage decay per period to decay per second

---
 src/dill/gauge-proxy-v2.sol | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index e74d49d0b..de7fb56a4 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -299,7 +299,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     mapping(address => uint256) public rewards;
     uint256 public rewardPerTokenStored;
     uint256 public rewardRate = 0;
-    uint256 public multiplierDecayPerPeriod = uint256(2876712e10);
+    uint256 public multiplierDecayPerSecond = uint256(48e9);
     mapping(address => uint256) private lastusedMultiplier;
     mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
 
@@ -429,15 +429,15 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return lock_multiplier;
     }
 
-    function _decayedLockMultiplier(address account, uint256 elapsedPeriods)
+    function _decayedLockMultiplier(address account, uint256 elapsedSeconds)
         internal
         view
         returns (uint256)
     {
         return
             (lastusedMultiplier[account] +
-                (elapsedPeriods - 1) *
-                multiplierDecayPerPeriod) / 2;
+                (elapsedSeconds - 1) *
+                multiplierDecayPerSecond) / 2;
     }
 
     function derivedBalance(address account) public returns (uint256) {
@@ -477,11 +477,11 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                     lock_multiplier = MULTIPLIER_PRECISION;
                 }
             } else {
-                uint256 elapsedPeriods = (block.timestamp - lastUpdateTime) / 7;
-                if (elapsedPeriods > 0) {
+                uint256 elapsedSeconds = (block.timestamp - lastUpdateTime);
+                if (elapsedSeconds > 0) {
                     lock_multiplier = _decayedLockMultiplier(
                         account,
-                        elapsedPeriods
+                        elapsedSeconds
                     );
                     lastusedMultiplier[account] = lock_multiplier;
                 }

From 2b1366ae30d4cb9d305cbe8be8fe6dad2857c745 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 14 Jun 2022 12:24:21 +0530
Subject: [PATCH 34/55] feat: liquidity locking

---
 src/dill/gauge-proxy-v2.sol                   | 126 +++---
 .../dill/05_gaugeV2_liquidityLocking.test.js  | 381 ++++++++++++++++++
 src/tests/dill/testHelper.js                  |  29 +-
 3 files changed, 466 insertions(+), 70 deletions(-)
 create mode 100644 src/tests/dill/05_gaugeV2_liquidityLocking.test.js

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index de7fb56a4..da4252eaf 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -279,29 +279,29 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         address(0x066419EaEf5DE53cc5da0d8702b990c5bc7D1AB3);
 
     // Constant for various precisions
-    uint256 private constant MULTIPLIER_PRECISION = 1e18;
+    uint256 private constant _MultiplierPrecision = 1e18;
 
     IERC20 public immutable TOKEN;
     address public immutable DISTRIBUTION;
     uint256 public constant DURATION = 7 days;
 
     // Lock time and multiplier settings
-    uint256 public lock_max_multiplier = uint256(25e17); // E18. 1x = e18
-    uint256 public lock_time_for_max_multiplier = 1 * 365 * 86400; // 1 year
-    uint256 public lock_time_min = 86400; // 1 * 86400  (1 day)
+    uint256 public lockMaxMultiplier = uint256(25e17); // E18. 1x = e18
+    uint256 public lockTimeForMaxMultiplier = 1 * 365 * 86400; // 1 year
+    uint256 public lockTimeMin = 86400; // 1 * 86400  (1 day)
 
     // Time tracking
     uint256 public periodFinish = 0;
     uint256 public lastUpdateTime;
-
+    mapping(address => uint256) public lastUpdateTimeForAccount;
     // Rewards tracking
     mapping(address => uint256) public userRewardPerTokenPaid;
     mapping(address => uint256) public rewards;
     uint256 public rewardPerTokenStored;
     uint256 public rewardRate = 0;
     uint256 public multiplierDecayPerSecond = uint256(48e9);
-    mapping(address => uint256) private lastusedMultiplier;
-    mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp
+    mapping(address => mapping(uint256 => uint256)) private _lastusedMultiplier;
+    mapping(address => uint256) private _lastRewardClaimTime; // staker addr -> timestamp
 
     // Balance tracking
     uint256 private _totalSupply;
@@ -311,7 +311,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     mapping(address => uint256) private _base;
 
     // Stake tracking
-    mapping(address => LockedStake[]) private lockedStakes;
+    mapping(address => LockedStake[]) private _lockedStakes;
 
     // Administrative booleans
     bool public stakesUnlocked; // Release locked stakes in case of emergency
@@ -345,9 +345,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     modifier lockable(uint256 secs) {
-        require(secs >= lock_time_min, "Minimum stake time not met");
+        require(secs >= lockTimeMin, "Minimum stake time not met");
         require(
-            secs <= lock_time_for_max_multiplier,
+            secs <= lockTimeForMaxMultiplier,
             "Trying to lock for too long"
         );
         _;
@@ -356,6 +356,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     modifier updateReward(address account) {
         rewardPerTokenStored = rewardPerToken();
         lastUpdateTime = lastTimeRewardApplicable();
+        lastUpdateTimeForAccount[account] = lastUpdateTime;
         if (account != address(0)) {
             rewards[account] = earned(account);
             userRewardPerTokenPaid[account] = rewardPerTokenStored;
@@ -405,7 +406,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         view
         returns (LockedStake[] memory)
     {
-        return lockedStakes[account];
+        return _lockedStakes[account];
     }
 
     function earned(address account) public view returns (uint256) {
@@ -421,21 +422,22 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     // Multiplier amount, given the length of the lock
     function lockMultiplier(uint256 secs) public view returns (uint256) {
-        uint256 lock_multiplier = uint256(MULTIPLIER_PRECISION) +
-            ((secs * (lock_max_multiplier - MULTIPLIER_PRECISION)) /
-                (lock_time_for_max_multiplier));
-        if (lock_multiplier > lock_max_multiplier)
-            lock_multiplier = lock_max_multiplier;
+        uint256 lock_multiplier = uint256(_MultiplierPrecision) +
+            ((secs * (lockMaxMultiplier - _MultiplierPrecision)) /
+                (lockTimeForMaxMultiplier));
+        if (lock_multiplier > lockMaxMultiplier)
+            lock_multiplier = lockMaxMultiplier;
         return lock_multiplier;
     }
 
-    function _decayedLockMultiplier(address account, uint256 elapsedSeconds)
-        internal
-        view
-        returns (uint256)
-    {
+    function _decayedLockMultiplier(
+        address account,
+        uint256 index,
+        uint256 elapsedSeconds
+    ) internal view returns (uint256) {
         return
-            (lastusedMultiplier[account] +
+            (2 *
+                _lastusedMultiplier[account][index] +
                 (elapsedSeconds - 1) *
                 multiplierDecayPerSecond) / 2;
     }
@@ -452,44 +454,49 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
         // 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];
+        for (uint256 i = 0; i < _lockedStakes[account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[account][i];
             uint256 lock_multiplier = thisStake.lock_multiplier;
 
             // If the lock is expired
             if (thisStake.ending_timestamp <= block.timestamp) {
                 // If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
-                if (lastRewardClaimTime[account] < thisStake.ending_timestamp) {
+                if (_lastRewardClaimTime[account] < thisStake.ending_timestamp) {
                     uint256 time_before_expiry = thisStake.ending_timestamp -
-                        lastRewardClaimTime[account];
+                        _lastRewardClaimTime[account];
                     uint256 time_after_expiry = block.timestamp -
                         thisStake.ending_timestamp;
 
                     // Get the weighted-average lock_multiplier
                     uint256 numerator = (lock_multiplier * time_before_expiry) +
-                        (MULTIPLIER_PRECISION * time_after_expiry);
+                        (_MultiplierPrecision * time_after_expiry);
                     lock_multiplier =
                         numerator /
                         (time_before_expiry + time_after_expiry);
                 }
                 // Otherwise, it needs to just be 1x
                 else {
-                    lock_multiplier = MULTIPLIER_PRECISION;
+                    lock_multiplier = _MultiplierPrecision;
                 }
             } else {
-                uint256 elapsedSeconds = (block.timestamp - lastUpdateTime);
+                uint256 elapsedSeconds = (block.timestamp -
+                    lastUpdateTimeForAccount[account]);
                 if (elapsedSeconds > 0) {
                     lock_multiplier = _decayedLockMultiplier(
                         account,
+                        i,
                         elapsedSeconds
                     );
-                    lastusedMultiplier[account] = lock_multiplier;
+                    _lastusedMultiplier[account][i] =
+                        _lastusedMultiplier[account][i] +
+                        (elapsedSeconds - 1) *
+                        multiplierDecayPerSecond;
                 }
             }
 
             uint256 liquidity = thisStake.liquidity;
             uint256 combined_boosted_amount = (liquidity * lock_multiplier) /
-                MULTIPLIER_PRECISION;
+                _MultiplierPrecision;
             lockBoostedDerivedBal =
                 lockBoostedDerivedBal +
                 combined_boosted_amount;
@@ -551,26 +558,28 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 start_timestamp
     ) internal nonReentrant updateReward(account) {
         require(amount > 0, "Cannot stake 0");
-        lastusedMultiplier[account] = lockMultiplier(secs);
-        lockedStakes[account].push(
+        uint256 MaxMultiplier = lockMultiplier(secs);
+        _lockedStakes[account].push(
             LockedStake(
                 start_timestamp,
                 amount,
                 start_timestamp + secs,
-                lastusedMultiplier[account]
+                MaxMultiplier
             )
         );
-
-        TOKEN.safeTransferFrom(account, address(this), amount);
+        _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;
+        if (_lastRewardClaimTime[account] == 0)
+            _lastRewardClaimTime[account] = block.timestamp;
 
-        emit Staked(account, amount, secs, lockedStakes[account].length - 1);
+        TOKEN.safeTransferFrom(account, address(this), amount);
+        emit Staked(account, amount, secs, _lockedStakes[account].length - 1);
     }
 
     function withdraw(uint256 index) external {
@@ -578,16 +587,20 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     function withdrawAll() public nonReentrant updateReward(msg.sender) {
-        for (uint256 i = 0; i < lockedStakes[msg.sender].length; i++) {
-            uint256 liquidity = lockedStakes[msg.sender][i].liquidity;
+        uint256 amount;
+        for (uint256 i = 0; i < _lockedStakes[msg.sender].length; i++) {
+            uint256 liquidity = _lockedStakes[msg.sender][i].liquidity;
             if (liquidity > 0) {
                 _totalSupply = _totalSupply - liquidity;
                 _balances[msg.sender] = _balances[msg.sender] - liquidity;
-                delete lockedStakes[msg.sender][i];
-                TOKEN.safeTransfer(msg.sender, liquidity);
-                emit Withdrawn(msg.sender, liquidity, i);
+                delete _lockedStakes[msg.sender][i];
+                amount += liquidity;
             }
         }
+        if (amount > 0) {
+            TOKEN.safeTransfer(msg.sender, amount);
+            emit WithdrawnAll(msg.sender, amount);
+        }
     }
 
     function _withdraw(uint256 index)
@@ -597,9 +610,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     {
         LockedStake memory thisStake;
         thisStake.liquidity = 0;
-        require(index < lockedStakes[msg.sender].length, "Stake not found");
+        require(index < _lockedStakes[msg.sender].length, "Stake not found");
 
-        thisStake = lockedStakes[msg.sender][index];
+        thisStake = _lockedStakes[msg.sender][index];
 
         require(
             block.timestamp >= thisStake.ending_timestamp ||
@@ -613,22 +626,20 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         if (liquidity > 0) {
             _totalSupply = _totalSupply - liquidity;
             _balances[msg.sender] = _balances[msg.sender] - liquidity;
-            delete lockedStakes[msg.sender][index];
+            delete _lockedStakes[msg.sender][index];
             TOKEN.safeTransfer(msg.sender, liquidity);
+            emit Withdrawn(msg.sender, liquidity, index);
         }
-
-        emit Withdrawn(msg.sender, liquidity, index);
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
         uint256 reward = rewards[msg.sender];
+        _lastRewardClaimTime[msg.sender] = block.timestamp;
         if (reward > 0) {
             rewards[msg.sender] = 0;
             PICKLE.safeTransfer(msg.sender, reward);
             emit RewardPaid(msg.sender, reward);
         }
-
-        lastRewardClaimTime[msg.sender] = block.timestamp;
     }
 
     function exit() external {
@@ -669,24 +680,24 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
             _lock_max_multiplier >= uint256(1e18),
             "Multiplier must be greater than or equal to 1e18"
         );
-        lock_max_multiplier = _lock_max_multiplier;
-        emit LockedStakeMaxMultiplierUpdated(lock_max_multiplier);
+        lockMaxMultiplier = _lock_max_multiplier;
+        emit LockedStakeMaxMultiplierUpdated(lockMaxMultiplier);
     }
 
-    function setMaxRewardsDuration(uint256 _lock_time_for_max_multiplier)
+    function setMaxRewardsDuration(uint256 _lockTimeForMaxMultiplier)
         external
         onlyGov
     {
         require(
-            _lock_time_for_max_multiplier >= 86400,
+            _lockTimeForMaxMultiplier >= 86400,
             "Rewards duration too short"
         );
         require(
             periodFinish == 0 || block.timestamp > periodFinish,
             "Reward period incomplete"
         );
-        lock_time_for_max_multiplier = _lock_time_for_max_multiplier;
-        emit MaxRewardsDurationUpdated(lock_time_for_max_multiplier);
+        lockTimeForMaxMultiplier = _lockTimeForMaxMultiplier;
+        emit MaxRewardsDurationUpdated(lockTimeForMaxMultiplier);
     }
 
     function unlockStakes() external onlyGov {
@@ -707,6 +718,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 index
     );
     event Withdrawn(address indexed user, uint256 amount, uint256 index);
+    event WithdrawnAll(address indexed user, uint256 amount);
     event RewardPaid(address indexed user, uint256 reward);
     event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
     event MaxRewardsDurationUpdated(uint256 newDuration);
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..7e093b597
--- /dev/null
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -0,0 +1,381 @@
+const {advanceNDays, advanceSevenDays} = require("./testHelper");
+const hre = require("hardhat");
+const {ethers} = require("hardhat");
+const {expect} = require("chai");
+
+const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
+const distributionAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
+const userAddr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
+const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
+const pickleHolder = "0xAC39564062A10d247a709bE49742C4622763E1d1";
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+let userSigner,
+  GaugeV2,
+  thisContractAddr,
+  GaugeFromUser,
+  pickle,
+  distributionSigner,
+  governanceSigner,
+  Luffy,
+  Zoro,
+  Sanji;
+
+describe("Liquidity Staking tests", () => {
+  before("Setting up gaugeV2", async () => {
+    const signer = ethers.provider.getSigner();
+    const pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    userSigner = ethers.provider.getSigner(userAddr);
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
+    distributionSigner = ethers.provider.getSigner(distributionAddr);
+
+    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: [distributionAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [userAddr],
+    });
+
+    await hre.network.provider.request({
+      method: "evm_unlockUnknownAccount",
+      params: [dillHolder],
+    });
+    [Luffy, Zoro, Sanji] = await ethers.getSigners();
+    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", distributionSigner);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr);
+    await GaugeV2.deployed();
+    thisContractAddr = GaugeV2.address;
+    console.log("GaugeV2 deployed to:", thisContractAddr);
+
+    GaugeFromUser = GaugeV2.connect(userSigner);
+    const pickleFromHolder = pickle.connect(pickleHolderSigner);
+
+    console.log("------------------------ Depositing pickle ------------------------");
+    await pickleFromHolder.transfer(distributionAddr, ethers.utils.parseEther("100"));
+    await pickleFromHolder.transfer(dillHolder, ethers.utils.parseEther("50"));
+    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"));
+  });
+
+  it("Should fail to stake when trying to stake for less than minimum time", async () => {
+    await expect(GaugeFromUser.depositAllAndLock(8640, {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, {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, {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, {
+      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 ", async () => {
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, 0);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
+    await expect(GaugeFromUser.notifyRewardAmount(bal, {gasLimit: 9000000})).to.be.revertedWith(
+      "Caller is not RewardsDistribution contract"
+    );
+  });
+
+  it("Should get reward amount successfully", async () => {
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, 0);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
+
+    await GaugeV2.notifyRewardAmount(bal, {
+      gasLimit: 9000000,
+    });
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRate())));
+    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 and get reward successfully", 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("===================================================================================================");
+
+    const fivePickle = ethers.utils.parseEther("5");
+    const dillHolderSigner = ethers.provider.getSigner(dillHolder);
+
+    const gaugeFromDillHolder = GaugeV2.connect(dillHolderSigner);
+
+    // 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, {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, {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, {gasLimit: 9000000});
+    console.log(
+      "Sanji's pickle balance after deposit and lock",
+      Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
+    );
+
+    const bal = await pickle.balanceOf(thisContractAddr);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, 0);
+    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
+    await GaugeV2.notifyRewardAmount(bal, {
+      gasLimit: 9000000,
+    });
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRate())));
+    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)))
+    );
+    console.log("--------------------------------------------------------------------------------------");
+  });
+
+  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);
+  });
+
+  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, {
+      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});
+  });
+});
diff --git a/src/tests/dill/testHelper.js b/src/tests/dill/testHelper.js
index 97c380e4c..4ac5262ed 100644
--- a/src/tests/dill/testHelper.js
+++ b/src/tests/dill/testHelper.js
@@ -1,30 +1,32 @@
 const hre = require("hardhat");
 const {ethers} = require("hardhat");
 
-// const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
-// const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
 
-async function advanceSevenDays() {
-  /** ************************************* increase time by 7 days ****************************************** */
-  console.log("-- Advancing 7 dyas --");
+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 * 7],
+    params: [3600 * 24 * days],
   });
 
-  /** ************************************* mine block ****************************************** */
+  /** ******************* 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 
+ *
+ * @param {contract} GaugeProxyV2
+ * @param {array} lpAddr
+ * @param {number} start
+ * @param {number} end
  * @returns array
  */
 async function distribute(GaugeProxyV2, lpAddr, start, end) {
@@ -42,11 +44,12 @@ async function distribute(GaugeProxyV2, lpAddr, start, end) {
     const rewardsGauge = await pickle.balanceOf(gaugeAddr);
     rewards.push(Number(rewardsGauge));
   });
-  
+
   return rewards;
 }
 
 module.exports = {
+  advanceNDays,
   advanceSevenDays,
   distribute,
 };

From 7ea40eb4ba3710f07786acdfafdc648b8c7c76a1 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 15 Jun 2022 19:42:32 +0530
Subject: [PATCH 35/55] feat: permanat stake lock

---
 src/dill/gauge-proxy-v2.sol | 120 ++++++++++++++++++++++++++----------
 1 file changed, 86 insertions(+), 34 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index da4252eaf..c4c28b5ec 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -294,9 +294,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     uint256 public periodFinish = 0;
     uint256 public lastUpdateTime;
     mapping(address => uint256) public lastUpdateTimeForAccount;
+
     // Rewards tracking
     mapping(address => uint256) public userRewardPerTokenPaid;
-    mapping(address => uint256) public rewards;
+    mapping(address => uint256) private _rewards;
     uint256 public rewardPerTokenStored;
     uint256 public rewardRate = 0;
     uint256 public multiplierDecayPerSecond = uint256(48e9);
@@ -310,6 +311,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     mapping(address => uint256) public derivedBalances;
     mapping(address => uint256) private _base;
 
+    // Deligate Tracting
+    mapping(address => mapping(address => bool)) public stakingDeligates;
+
     // Stake tracking
     mapping(address => LockedStake[]) private _lockedStakes;
 
@@ -324,6 +328,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 liquidity;
         uint256 ending_timestamp;
         uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+        bool isPermanentlyLocked;
     }
 
     /* ========== MODIFIERS ========== */
@@ -358,7 +363,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         lastUpdateTime = lastTimeRewardApplicable();
         lastUpdateTimeForAccount[account] = lastUpdateTime;
         if (account != address(0)) {
-            rewards[account] = earned(account);
+            _rewards[account] = earned(account);
             userRewardPerTokenPaid[account] = rewardPerTokenStored;
         }
         _;
@@ -413,7 +418,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return
             ((derivedBalances[account] *
                 (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
-            rewards[account];
+            _rewards[account];
     }
 
     function getRewardForDuration() external view returns (uint256) {
@@ -459,9 +464,14 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
             uint256 lock_multiplier = thisStake.lock_multiplier;
 
             // If the lock is expired
-            if (thisStake.ending_timestamp <= block.timestamp) {
+            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[account] < thisStake.ending_timestamp) {
+                if (
+                    _lastRewardClaimTime[account] < thisStake.ending_timestamp
+                ) {
                     uint256 time_before_expiry = thisStake.ending_timestamp -
                         _lastRewardClaimTime[account];
                     uint256 time_after_expiry = block.timestamp -
@@ -482,11 +492,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 uint256 elapsedSeconds = (block.timestamp -
                     lastUpdateTimeForAccount[account]);
                 if (elapsedSeconds > 0) {
-                    lock_multiplier = _decayedLockMultiplier(
-                        account,
-                        i,
-                        elapsedSeconds
-                    );
+                    lock_multiplier = thisStake.isPermanentlyLocked
+                        ? lockMaxMultiplier
+                        : _decayedLockMultiplier(account, i, elapsedSeconds);
                     _lastusedMultiplier[account][i] =
                         _lastusedMultiplier[account][i] +
                         (elapsedSeconds - 1) *
@@ -515,47 +523,74 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         derivedSupply = derivedSupply + _derivedBalance;
     }
 
-    function depositAllAndLock(uint256 secs) external lockable(secs) {
+    function depositAllAndLock(uint256 secs, bool isPermanentlyLocked)
+        external
+        lockable(secs)
+    {
         _deposit(
             TOKEN.balanceOf(msg.sender),
             msg.sender,
             secs,
-            block.timestamp
+            block.timestamp,
+            isPermanentlyLocked
         );
     }
 
     function depositAll() external {
-        _deposit(TOKEN.balanceOf(msg.sender), msg.sender, 0, block.timestamp);
+        _deposit(
+            TOKEN.balanceOf(msg.sender),
+            msg.sender,
+            0,
+            block.timestamp,
+            false
+        );
     }
 
     function depositFor(uint256 amount, address account) external {
-        _deposit(amount, account, 0, block.timestamp);
+        require(
+            stakingDeligates[account][msg.sender],
+            "Only registerd deligates can deposit for their deligator"
+        );
+        _deposit(amount, account, 0, block.timestamp, false);
     }
 
     function depositForAndLock(
         uint256 amount,
         address account,
-        uint256 secs
+        uint256 secs,
+        bool isPermanentlyLocked
     ) external lockable(secs) {
-        _deposit(amount, account, secs, block.timestamp);
+        require(
+            stakingDeligates[account][msg.sender],
+            "Only registerd deligates can stake for their deligator"
+        );
+        _deposit(amount, account, secs, block.timestamp, isPermanentlyLocked);
     }
 
     function deposit(uint256 amount) external {
-        _deposit(amount, msg.sender, 0, block.timestamp);
+        _deposit(amount, msg.sender, 0, block.timestamp, false);
     }
 
-    function depositAndLock(uint256 amount, uint256 secs)
-        external
-        lockable(secs)
-    {
-        _deposit(amount, msg.sender, secs, block.timestamp);
+    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
+        uint256 start_timestamp,
+        bool isPermanentlyLocked
     ) internal nonReentrant updateReward(account) {
         require(amount > 0, "Cannot stake 0");
         uint256 MaxMultiplier = lockMultiplier(secs);
@@ -564,7 +599,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 start_timestamp,
                 amount,
                 start_timestamp + secs,
-                MaxMultiplier
+                MaxMultiplier,
+                isPermanentlyLocked
             )
         );
         _lastusedMultiplier[account][
@@ -589,8 +625,18 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     function withdrawAll() public nonReentrant updateReward(msg.sender) {
         uint256 amount;
         for (uint256 i = 0; i < _lockedStakes[msg.sender].length; i++) {
-            uint256 liquidity = _lockedStakes[msg.sender][i].liquidity;
-            if (liquidity > 0) {
+            LockedStake memory thisStake = _lockedStakes[msg.sender][i];
+            uint256 liquidity = thisStake.liquidity;
+            if (
+                liquidity > 0 &&
+                (stakesUnlocked ||
+                    stakesUnlockedForAccount[msg.sender] ||
+                    (
+                        thisStake.isPermanentlyLocked
+                            ? false
+                            : block.timestamp >= thisStake.ending_timestamp
+                    ))
+            ) {
                 _totalSupply = _totalSupply - liquidity;
                 _balances[msg.sender] = _balances[msg.sender] - liquidity;
                 delete _lockedStakes[msg.sender][i];
@@ -615,9 +661,13 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         thisStake = _lockedStakes[msg.sender][index];
 
         require(
-            block.timestamp >= thisStake.ending_timestamp ||
-                stakesUnlocked == true ||
-                stakesUnlockedForAccount[msg.sender] == true,
+            stakesUnlocked ||
+                stakesUnlockedForAccount[msg.sender] ||
+                (
+                    thisStake.isPermanentlyLocked
+                        ? false
+                        : block.timestamp >= thisStake.ending_timestamp
+                ),
             "Stake is still locked!"
         );
 
@@ -633,10 +683,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
-        uint256 reward = rewards[msg.sender];
+        uint256 reward = _rewards[msg.sender];
         _lastRewardClaimTime[msg.sender] = block.timestamp;
         if (reward > 0) {
-            rewards[msg.sender] = 0;
+            _rewards[msg.sender] = 0;
             PICKLE.safeTransfer(msg.sender, reward);
             emit RewardPaid(msg.sender, reward);
         }
@@ -709,7 +759,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     /* ========== EVENTS ========== */
-
+    event approvedTokenReceipt(address _spender, uint256 _amount);
+    event stakeTransferd(address _to, uint256 _index);
+    event allStakesTransferd(address _to);
     event RewardAdded(uint256 reward);
     event Staked(
         address indexed user,
@@ -761,7 +813,7 @@ contract MasterDill {
         uint256 amount
     );
 
-    constructor() public {
+    constructor() {
         balances[msg.sender] = 1e18;
         emit Transfer(address(0x0), msg.sender, 1e18);
     }
@@ -1050,7 +1102,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         }
 
         delete tokenVote[_owner];
-        // Ensure distribute rewards are for current period
+        // Ensure distribute _rewards are for current period
         periodForDistribute[_currentId] = _currentId;
     }
 

From 25e4e5e6adbd6d4a1a2d911444c74f39533f7ab0 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 16 Jun 2022 11:45:34 +0530
Subject: [PATCH 36/55] feat: add setDelegate method

---
 src/dill/gauge-proxy-v2.sol | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index c4c28b5ec..7ff80542f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -311,8 +311,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     mapping(address => uint256) public derivedBalances;
     mapping(address => uint256) private _base;
 
-    // Deligate Tracting
-    mapping(address => mapping(address => bool)) public stakingDeligates;
+    // Delegate tracking
+    mapping(address => mapping(address => bool)) public stakingDelegates;
 
     // Stake tracking
     mapping(address => LockedStake[]) private _lockedStakes;
@@ -447,6 +447,12 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 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;
@@ -548,8 +554,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     function depositFor(uint256 amount, address account) external {
         require(
-            stakingDeligates[account][msg.sender],
-            "Only registerd deligates can deposit for their deligator"
+            stakingDelegates[account][msg.sender],
+            "Only registerd delegates can deposit for their deligator"
         );
         _deposit(amount, account, 0, block.timestamp, false);
     }
@@ -561,8 +567,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         bool isPermanentlyLocked
     ) external lockable(secs) {
         require(
-            stakingDeligates[account][msg.sender],
-            "Only registerd deligates can stake for their deligator"
+            stakingDelegates[account][msg.sender],
+            "Only registerd delegates can stake for their deligator"
         );
         _deposit(amount, account, secs, block.timestamp, isPermanentlyLocked);
     }
@@ -631,11 +637,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 liquidity > 0 &&
                 (stakesUnlocked ||
                     stakesUnlockedForAccount[msg.sender] ||
-                    (
-                        thisStake.isPermanentlyLocked
-                            ? false
-                            : block.timestamp >= thisStake.ending_timestamp
-                    ))
+                    (!thisStake.isPermanentlyLocked &&
+                        block.timestamp >= thisStake.ending_timestamp))
             ) {
                 _totalSupply = _totalSupply - liquidity;
                 _balances[msg.sender] = _balances[msg.sender] - liquidity;

From b49bcff1d52f0038b991a3db82855c65b5d4d571 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Mon, 20 Jun 2022 18:04:16 +0530
Subject: [PATCH 37/55] feat:add support for multiple reward tokens

---
 src/dill/gauge-proxy-v2.sol | 199 +++++++++++++++++++++++++++---------
 1 file changed, 148 insertions(+), 51 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 7ff80542f..5c550bd9f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -290,18 +290,24 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     uint256 public lockTimeForMaxMultiplier = 1 * 365 * 86400; // 1 year
     uint256 public lockTimeMin = 86400; // 1 * 86400  (1 day)
 
+    //Reward addresses, rates, and symbols
+    address[] public rewardTokens;
+    uint256[] public rewardRates;
+    string[] public rewardSymbols;
+    mapping(address => uint256) public rewardTokenAddrToIdx;
+
     // Time tracking
     uint256 public periodFinish = 0;
     uint256 public lastUpdateTime;
     mapping(address => uint256) public lastUpdateTimeForAccount;
 
     // Rewards tracking
-    mapping(address => uint256) public userRewardPerTokenPaid;
-    mapping(address => uint256) private _rewards;
-    uint256 public rewardPerTokenStored;
-    uint256 public rewardRate = 0;
+    mapping(address => mapping(uint256 => uint256))
+        private userRewardPerTokenPaid;
+    mapping(address => mapping(uint256 => uint256)) private _rewards;
+    uint256[] private rewardPerTokenStored;
     uint256 public multiplierDecayPerSecond = uint256(48e9);
-    mapping(address => mapping(uint256 => uint256)) private _lastusedMultiplier;
+    mapping(address => mapping(uint256 => uint256)) private _lastUsedMultiplier;
     mapping(address => uint256) private _lastRewardClaimTime; // staker addr -> timestamp
 
     // Balance tracking
@@ -361,10 +367,13 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     modifier updateReward(address account) {
         rewardPerTokenStored = rewardPerToken();
         lastUpdateTime = lastTimeRewardApplicable();
-        lastUpdateTimeForAccount[account] = lastUpdateTime;
+        lastUpdateTimeForAccount[account] = block.timestamp;
         if (account != address(0)) {
-            _rewards[account] = earned(account);
-            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+            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)) {
@@ -374,10 +383,28 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     /* ========== CONSTRUCTOR ========== */
 
-    constructor(address _token, address _governance) {
+    constructor(
+        address _token,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) {
         TOKEN = IERC20(_token);
+
+        rewardTokens = _rewardTokens;
+        rewardSymbols = _rewardSymbols;
+
         DISTRIBUTION = msg.sender;
         governance = _governance;
+
+        for (uint256 i = 0; i < _rewardTokens.length; i++) {
+            // For fast token address -> token ID lookups later
+            rewardTokenAddrToIdx[_rewardTokens[i]] = i;
+
+            // Initialize the stored rewards
+            rewardRates.push(0);
+            rewardPerTokenStored.push(0);
+        }
     }
 
     /* ========== VIEWS ========== */
@@ -394,15 +421,23 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return Math.min(block.timestamp, periodFinish);
     }
 
-    function rewardPerToken() public view returns (uint256) {
+    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++) {
+                rewardPerTokenStored[i] +
+                    (((lastTimeRewardApplicable() - lastUpdateTime) *
+                        rewardRates[i] *
+                        1e18) / derivedSupply);
+            }
+            return newRewardsPerTokenStored;
         }
-        return
-            rewardPerTokenStored +
-            (((lastTimeRewardApplicable() - lastUpdateTime) *
-                rewardRate *
-                1e18) / derivedSupply);
     }
 
     // All the locked stakes for a given account
@@ -414,15 +449,39 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return _lockedStakes[account];
     }
 
-    function earned(address account) public view returns (uint256) {
-        return
-            ((derivedBalances[account] *
-                (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
-            _rewards[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) {
-        return rewardRate * DURATION;
+    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
@@ -435,20 +494,23 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         return lock_multiplier;
     }
 
-    function _decayedLockMultiplier(
+    function _averageDecayedLockMultiplier(
         address account,
         uint256 index,
         uint256 elapsedSeconds
     ) internal view returns (uint256) {
         return
             (2 *
-                _lastusedMultiplier[account][index] +
+                _lastUsedMultiplier[account][index] -
                 (elapsedSeconds - 1) *
                 multiplierDecayPerSecond) / 2;
     }
 
-    function setStakingDelegate(address _delegate) public{
-        require(stakingDelegates[msg.sender][_delegate], "Already a staking delegate for user!");
+    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;
     }
@@ -478,17 +540,17 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 if (
                     _lastRewardClaimTime[account] < thisStake.ending_timestamp
                 ) {
-                    uint256 time_before_expiry = thisStake.ending_timestamp -
+                    uint256 timeBeforeExpiry = thisStake.ending_timestamp -
                         _lastRewardClaimTime[account];
-                    uint256 time_after_expiry = block.timestamp -
+                    uint256 timeAfterExpiry = block.timestamp -
                         thisStake.ending_timestamp;
 
                     // Get the weighted-average lock_multiplier
-                    uint256 numerator = (lock_multiplier * time_before_expiry) +
-                        (_MultiplierPrecision * time_after_expiry);
+                    uint256 numerator = (lock_multiplier * timeBeforeExpiry) +
+                        (_MultiplierPrecision * timeAfterExpiry);
                     lock_multiplier =
                         numerator /
-                        (time_before_expiry + time_after_expiry);
+                        (timeBeforeExpiry + timeAfterExpiry);
                 }
                 // Otherwise, it needs to just be 1x
                 else {
@@ -500,9 +562,13 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 if (elapsedSeconds > 0) {
                     lock_multiplier = thisStake.isPermanentlyLocked
                         ? lockMaxMultiplier
-                        : _decayedLockMultiplier(account, i, elapsedSeconds);
-                    _lastusedMultiplier[account][i] =
-                        _lastusedMultiplier[account][i] +
+                        : _averageDecayedLockMultiplier(
+                            account,
+                            i,
+                            elapsedSeconds
+                        );
+                    _lastUsedMultiplier[account][i] =
+                        _lastUsedMultiplier[account][i] -
                         (elapsedSeconds - 1) *
                         multiplierDecayPerSecond;
                 }
@@ -609,7 +675,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 isPermanentlyLocked
             )
         );
-        _lastusedMultiplier[account][
+        _lastUsedMultiplier[account][
             _lockedStakes[account].length - 1
         ] = MaxMultiplier;
 
@@ -686,12 +752,15 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
-        uint256 reward = _rewards[msg.sender];
+        uint256[] memory reward = new uint256[](rewardTokens.length);
         _lastRewardClaimTime[msg.sender] = block.timestamp;
-        if (reward > 0) {
-            _rewards[msg.sender] = 0;
-            PICKLE.safeTransfer(msg.sender, reward);
-            emit RewardPaid(msg.sender, reward);
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            if (reward[i] > 0) {
+                _rewards[msg.sender][i] = 0;
+                PICKLE.safeTransfer(msg.sender, reward[i]);
+                emit RewardPaid(msg.sender, reward[i]);
+            }
         }
     }
 
@@ -707,21 +776,43 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         onlyDistribution
         updateReward(address(0))
     {
-        PICKLE.safeTransferFrom(DISTRIBUTION, address(this), reward);
-        if (block.timestamp >= periodFinish) {
-            rewardRate = reward / DURATION;
-        } else {
-            uint256 remaining = periodFinish - block.timestamp;
-            uint256 leftover = remaining * rewardRate;
-            rewardRate = (reward + leftover) / DURATION;
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            IERC20(rewardTokens[i]).safeTransferFrom(
+                DISTRIBUTION,
+                address(this),
+                reward
+            );
+
+            if (block.timestamp >= periodFinish) {
+                rewardRates[i] = reward / DURATION;
+            } else {
+                uint256 remaining = periodFinish - block.timestamp;
+                uint256 leftover = remaining * rewardRates[i];
+                rewardRates[i] = (reward + 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 = PICKLE.balanceOf(address(this));
-        require(rewardRate <= balance / DURATION, "Provided reward too high");
+
+        uint256 numPeriodsElapsed = uint256(block.timestamp - periodFinish) /
+            DURATION; // Floor division to the nearest period
+
+        // Make sure there are enough tokens to renew the reward period
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            require(
+                rewardRates[i] * DURATION * (numPeriodsElapsed + 1) <=
+                    IERC20(rewardTokens[i]).balanceOf(address(this)),
+                string(
+                    abi.encodePacked(
+                        "Not enough reward tokens available: ",
+                        rewardTokens[i]
+                    )
+                )
+            );
+        }
 
         lastUpdateTime = block.timestamp;
         periodFinish = block.timestamp + DURATION;
@@ -1249,10 +1340,16 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     // Add new token gauge
-    function addGauge(address _token) external {
+    function addGauge(
+        address _token,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
-        gauges[_token] = address(new GaugeV2(_token, governance));
+        gauges[_token] = address(
+            new GaugeV2(_token, governance, _rewardSymbols, _rewardTokens)
+        );
         _tokens.push(_token);
     }
 

From 1196a915a130ceb23f12b019db8e6f658f3b6c8e Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 21 Jun 2022 17:51:34 +0530
Subject: [PATCH 38/55] fix: notifyReward for multiple tokens

---
 src/dill/gauge-proxy-v2.sol | 49 +++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 5c550bd9f..7826663bd 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -293,8 +293,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     //Reward addresses, rates, and symbols
     address[] public rewardTokens;
     uint256[] public rewardRates;
-    string[] public rewardSymbols;
-    mapping(address => uint256) public rewardTokenAddrToIdx;
+    bytes32[] public rewardSymbols;
 
     // Time tracking
     uint256 public periodFinish = 0;
@@ -386,7 +385,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     constructor(
         address _token,
         address _governance,
-        string[] memory _rewardSymbols,
+        bytes32[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) {
         TOKEN = IERC20(_token);
@@ -398,9 +397,6 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         governance = _governance;
 
         for (uint256 i = 0; i < _rewardTokens.length; i++) {
-            // For fast token address -> token ID lookups later
-            rewardTokenAddrToIdx[_rewardTokens[i]] = i;
-
             // Initialize the stored rewards
             rewardRates.push(0);
             rewardPerTokenStored.push(0);
@@ -759,7 +755,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
             if (reward[i] > 0) {
                 _rewards[msg.sender][i] = 0;
                 PICKLE.safeTransfer(msg.sender, reward[i]);
-                emit RewardPaid(msg.sender, reward[i]);
+                emit RewardPaid(msg.sender, rewardSymbols[i], reward[i]);
             }
         }
     }
@@ -771,25 +767,30 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     /* ========== RESTRICTED FUNCTIONS ========== */
 
-    function notifyRewardAmount(uint256 reward)
+    function notifyRewardAmount(uint256[] memory rewards)
         external
         onlyDistribution
         updateReward(address(0))
     {
+        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),
-                reward
+                rewards[i]
             );
 
             if (block.timestamp >= periodFinish) {
-                rewardRates[i] = reward / DURATION;
+                rewardRates[i] = rewards[i] / DURATION;
             } else {
                 uint256 remaining = periodFinish - block.timestamp;
                 uint256 leftover = remaining * rewardRates[i];
-                rewardRates[i] = (reward + leftover) / DURATION;
+                rewardRates[i] = (rewards[i] + leftover) / DURATION;
             }
+            emit RewardAdded(rewardSymbols[i], rewards[i]);
         }
 
         // Ensure the provided reward amount is not more than the balance in the contract.
@@ -816,7 +817,6 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
         lastUpdateTime = block.timestamp;
         periodFinish = block.timestamp + DURATION;
-        emit RewardAdded(reward);
     }
 
     function setMultipliers(uint256 _lock_max_multiplier) external onlyGov {
@@ -856,7 +856,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     event approvedTokenReceipt(address _spender, uint256 _amount);
     event stakeTransferd(address _to, uint256 _index);
     event allStakesTransferd(address _to);
-    event RewardAdded(uint256 reward);
+    event RewardAdded(bytes32 rewardSymbol, uint256 reward);
     event Staked(
         address indexed user,
         uint256 amount,
@@ -865,7 +865,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     );
     event Withdrawn(address indexed user, uint256 amount, uint256 index);
     event WithdrawnAll(address indexed user, uint256 amount);
-    event RewardPaid(address indexed user, uint256 reward);
+    event RewardPaid(address indexed user, bytes32 rewardSymbol, uint256 reward);
     event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
     event MaxRewardsDurationUpdated(uint256 newDuration);
 }
@@ -1340,13 +1340,15 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     // Add new token gauge
-    function addGauge(
-        address _token,
-        string[] memory _rewardSymbols,
-        address[] memory _rewardTokens
-    ) external {
+    function addGauge(address _token) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
+
+        bytes32[] memory _rewardSymbols = new bytes32[](1);
+        address[] memory _rewardTokens = new address[](1);
+        _rewardSymbols[0] = "PICKLE";
+        _rewardTokens[0] = _token;
+
         gauges[_token] = address(
             new GaugeV2(_token, governance, _rewardSymbols, _rewardTokens)
         );
@@ -1449,9 +1451,14 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 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, uint256(_reward));
-                    GaugeV2(_gauge).notifyRewardAmount(uint256(_reward));
+                    PICKLE.safeApprove(_gauge, reward_);
+
+                    GaugeV2(_gauge).notifyRewardAmount(rewardArr);
                 }
 
                 if (_reward < 0) {

From fcc128db30c1d57f8aa34dd416f491b9b0b852c3 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 23 Jun 2022 18:07:13 +0530
Subject: [PATCH 39/55] fix: minor fixes

---
 src/dill/gauge-proxy-v2.sol | 59 +++++++++++++++----------------------
 1 file changed, 24 insertions(+), 35 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 7826663bd..0cd8695f3 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -293,7 +293,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     //Reward addresses, rates, and symbols
     address[] public rewardTokens;
     uint256[] public rewardRates;
-    bytes32[] public rewardSymbols;
+    string[] public rewardSymbols;
 
     // Time tracking
     uint256 public periodFinish = 0;
@@ -385,7 +385,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     constructor(
         address _token,
         address _governance,
-        bytes32[] memory _rewardSymbols,
+        string[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) {
         TOKEN = IERC20(_token);
@@ -427,7 +427,8 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         } else {
             newRewardsPerTokenStored = new uint256[](rewardTokens.length);
             for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
-                rewardPerTokenStored[i] +
+                newRewardsPerTokenStored[i] =
+                    rewardPerTokenStored[i] +
                     (((lastTimeRewardApplicable() - lastUpdateTime) *
                         rewardRates[i] *
                         1e18) / derivedSupply);
@@ -526,18 +527,16 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         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[account] < thisStake.ending_timestamp
-                ) {
+                if (lastRewardClaimTime < thisStake.ending_timestamp) {
                     uint256 timeBeforeExpiry = thisStake.ending_timestamp -
-                        _lastRewardClaimTime[account];
+                        lastRewardClaimTime;
                     uint256 timeAfterExpiry = block.timestamp -
                         thisStake.ending_timestamp;
 
@@ -748,14 +747,15 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     }
 
     function getReward() public nonReentrant updateReward(msg.sender) {
-        uint256[] memory reward = new uint256[](rewardTokens.length);
+        uint256 reward;
         _lastRewardClaimTime[msg.sender] = block.timestamp;
 
         for (uint256 i = 0; i < rewardTokens.length; i++) {
-            if (reward[i] > 0) {
+            reward = _rewards[msg.sender][i];
+            if (reward > 0) {
                 _rewards[msg.sender][i] = 0;
-                PICKLE.safeTransfer(msg.sender, reward[i]);
-                emit RewardPaid(msg.sender, rewardSymbols[i], reward[i]);
+                IERC20(rewardTokens[i]).safeTransfer(msg.sender, reward);
+                emit RewardPaid(msg.sender, rewardSymbols[i], reward);
             }
         }
     }
@@ -790,29 +790,18 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                 uint256 leftover = remaining * rewardRates[i];
                 rewardRates[i] = (rewards[i] + leftover) / DURATION;
             }
-            emit RewardAdded(rewardSymbols[i], rewards[i]);
-        }
-
-        // 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 numPeriodsElapsed = uint256(block.timestamp - periodFinish) /
-            DURATION; // Floor division to the nearest period
-
-        // Make sure there are enough tokens to renew the reward period
-        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            // 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] * DURATION * (numPeriodsElapsed + 1) <=
-                    IERC20(rewardTokens[i]).balanceOf(address(this)),
-                string(
-                    abi.encodePacked(
-                        "Not enough reward tokens available: ",
-                        rewardTokens[i]
-                    )
-                )
+                rewardRates[i] <= balance / DURATION,
+                "Provided reward too high"
             );
+
+            emit RewardAdded(rewardSymbols[i], rewards[i]);
         }
 
         lastUpdateTime = block.timestamp;
@@ -856,7 +845,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     event approvedTokenReceipt(address _spender, uint256 _amount);
     event stakeTransferd(address _to, uint256 _index);
     event allStakesTransferd(address _to);
-    event RewardAdded(bytes32 rewardSymbol, uint256 reward);
+    event RewardAdded(string rewardSymbol, uint256 reward);
     event Staked(
         address indexed user,
         uint256 amount,
@@ -865,7 +854,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     );
     event Withdrawn(address indexed user, uint256 amount, uint256 index);
     event WithdrawnAll(address indexed user, uint256 amount);
-    event RewardPaid(address indexed user, bytes32 rewardSymbol, uint256 reward);
+    event RewardPaid(address indexed user, string rewardSymbol, uint256 reward);
     event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
     event MaxRewardsDurationUpdated(uint256 newDuration);
 }
@@ -1344,7 +1333,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
 
-        bytes32[] memory _rewardSymbols = new bytes32[](1);
+        string[] memory _rewardSymbols = new string[](1);
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
         _rewardTokens[0] = _token;

From 817ee69c34c8b96eac4da9410d8122b7f0e2a24e Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Wed, 29 Jun 2022 21:21:58 +0530
Subject: [PATCH 40/55] fix: minor fixes

---
 src/dill/gauge-proxy-v2.sol | 71 ++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 44 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 0cd8695f3..5bde86375 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.1; // ^0.6.7; //^0.7.5;
+pragma solidity ^0.8.1;
 
 library Address {
     function isContract(address account) internal view returns (bool) {
@@ -122,12 +122,7 @@ library SafeERC20 {
         address spender,
         uint256 value
     ) internal {
-        uint256 newAllowance = token.allowance(address(this), spender) -
-            (
-                value
-                // ,
-                // "SafeERC20: decreased allowance below zero"
-            );
+        uint256 newAllowance = token.allowance(address(this), spender) - value;
         callOptionalReturn(
             token,
             abi.encodeWithSelector(
@@ -214,7 +209,6 @@ abstract contract ReentrancyGuard {
 
     uint256 private _status;
 
-    // constructor() public {
     constructor() {
         _status = _NOT_ENTERED;
     }
@@ -285,10 +279,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     address public immutable DISTRIBUTION;
     uint256 public constant DURATION = 7 days;
 
-    // Lock time and multiplier settings
+    // Lock time and multiplier
     uint256 public lockMaxMultiplier = uint256(25e17); // E18. 1x = e18
-    uint256 public lockTimeForMaxMultiplier = 1 * 365 * 86400; // 1 year
-    uint256 public lockTimeMin = 86400; // 1 * 86400  (1 day)
+    uint256 public lockTimeForMaxMultiplier = 365 * 86400; // 1 year
+    uint256 public lockTimeMin = 86400; // 1 day
 
     //Reward addresses, rates, and symbols
     address[] public rewardTokens;
@@ -298,12 +292,11 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     // Time tracking
     uint256 public periodFinish = 0;
     uint256 public lastUpdateTime;
-    mapping(address => uint256) public lastUpdateTimeForAccount;
 
     // Rewards tracking
     mapping(address => mapping(uint256 => uint256))
         private userRewardPerTokenPaid;
-    mapping(address => mapping(uint256 => uint256)) private _rewards;
+    mapping(address => mapping(uint256 => uint256)) public _rewards;
     uint256[] private rewardPerTokenStored;
     uint256 public multiplierDecayPerSecond = uint256(48e9);
     mapping(address => mapping(uint256 => uint256)) private _lastUsedMultiplier;
@@ -363,10 +356,10 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         _;
     }
 
-    modifier updateReward(address account) {
+    modifier updateReward(address account, bool isClaimReward) {
         rewardPerTokenStored = rewardPerToken();
         lastUpdateTime = lastTimeRewardApplicable();
-        lastUpdateTimeForAccount[account] = block.timestamp;
+
         if (account != address(0)) {
             uint256[] memory earnedArr = earned(account);
             for (uint256 i = 0; i < rewardPerTokenStored.length; i++) {
@@ -377,6 +370,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         _;
         if (account != address(0)) {
             kick(account);
+            if (isClaimReward) {
+                _lastRewardClaimTime[account] = block.timestamp;
+            }
         }
     }
 
@@ -552,8 +548,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                     lock_multiplier = _MultiplierPrecision;
                 }
             } else {
-                uint256 elapsedSeconds = (block.timestamp -
-                    lastUpdateTimeForAccount[account]);
+                uint256 elapsedSeconds = block.timestamp - lastRewardClaimTime;
                 if (elapsedSeconds > 0) {
                     lock_multiplier = thisStake.isPermanentlyLocked
                         ? lockMaxMultiplier
@@ -568,7 +563,6 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                         multiplierDecayPerSecond;
                 }
             }
-
             uint256 liquidity = thisStake.liquidity;
             uint256 combined_boosted_amount = (liquidity * lock_multiplier) /
                 _MultiplierPrecision;
@@ -658,7 +652,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 secs,
         uint256 start_timestamp,
         bool isPermanentlyLocked
-    ) internal nonReentrant updateReward(account) {
+    ) internal nonReentrant updateReward(account, false) {
         require(amount > 0, "Cannot stake 0");
         uint256 MaxMultiplier = lockMultiplier(secs);
         _lockedStakes[account].push(
@@ -689,7 +683,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         _withdraw(index);
     }
 
-    function withdrawAll() public nonReentrant updateReward(msg.sender) {
+    function withdrawAll() public nonReentrant updateReward(msg.sender, false) {
         uint256 amount;
         for (uint256 i = 0; i < _lockedStakes[msg.sender].length; i++) {
             LockedStake memory thisStake = _lockedStakes[msg.sender][i];
@@ -716,7 +710,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     function _withdraw(uint256 index)
         internal
         nonReentrant
-        updateReward(msg.sender)
+        updateReward(msg.sender, false)
     {
         LockedStake memory thisStake;
         thisStake.liquidity = 0;
@@ -746,9 +740,9 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         }
     }
 
-    function getReward() public nonReentrant updateReward(msg.sender) {
+    function getReward() public nonReentrant updateReward(msg.sender, true) {
         uint256 reward;
-        _lastRewardClaimTime[msg.sender] = block.timestamp;
+        // _lastRewardClaimTime[msg.sender] = block.timestamp;
 
         for (uint256 i = 0; i < rewardTokens.length; i++) {
             reward = _rewards[msg.sender][i];
@@ -770,7 +764,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     function notifyRewardAmount(uint256[] memory rewards)
         external
         onlyDistribution
-        updateReward(address(0))
+        updateReward(address(0), false)
     {
         require(
             rewards.length == rewardTokens.length,
@@ -964,15 +958,13 @@ contract MasterDill {
     ) external returns (bool) {
         address spender = msg.sender;
         uint256 spenderAllowance = allowances[src][spender];
-
-        // if (spender != src && spenderAllowance != uint256(-1)) { // type(uint256).max
+        require(
+            amount <= spenderAllowance,
+            "transferFrom: exceeds spender allowance"
+        );
+        
         if (spender != src && spenderAllowance != type(uint256).max) {
-            uint256 newAllowance = spenderAllowance -
-                (
-                    amount
-                    // ,
-                    // "transferFrom: exceeds spender allowance"
-                );
+            uint256 newAllowance = spenderAllowance - amount;
             allowances[src][spender] = newAllowance;
 
             emit Approval(src, spender, newAllowance);
@@ -989,19 +981,10 @@ contract MasterDill {
     ) internal {
         require(src != address(0), "_transferTokens: zero address");
         require(dst != address(0), "_transferTokens: zero address");
+        require(amount <= balances[src], "_transferTokens: exceeds balance");
 
-        balances[src] =
-            balances[src] -
-            (
-                amount
-                // ,
-                // "_transferTokens: exceeds balance"
-            );
-        balances[dst] += (
-            amount
-            // ,
-            //  "_transferTokens: overflows"
-        );
+        balances[src] -= amount;
+        balances[dst] += amount;
         emit Transfer(src, dst, amount);
     }
 }

From e31da249d3232a4cd0a43af16b1f86712146cba2 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 30 Jun 2022 19:32:15 +0530
Subject: [PATCH 41/55] feat: situational test

---
 .../dill/05_gaugeV2_liquidityLocking.test.js  |  95 ++++---
 .../dill/06_GaugeV2_situtational.test.js      | 248 ++++++++++++++++++
 2 files changed, 306 insertions(+), 37 deletions(-)
 create mode 100644 src/tests/dill/06_GaugeV2_situtational.test.js

diff --git a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
index 7e093b597..6135d8a47 100644
--- a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -4,29 +4,30 @@ const {ethers} = require("hardhat");
 const {expect} = require("chai");
 
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
-const distributionAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const userAddr = "0x5c4D8CEE7dE74E31cE69E76276d862180545c307";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
-const pickleHolder = "0xAC39564062A10d247a709bE49742C4622763E1d1";
+const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
 const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
 let userSigner,
   GaugeV2,
   thisContractAddr,
   GaugeFromUser,
   pickle,
-  distributionSigner,
+  pickleHolderSigner,
   governanceSigner,
   Luffy,
   Zoro,
-  Sanji;
+  Sanji,
+  Nami;
+const fivePickle = ethers.utils.parseEther("5");
 
 describe("Liquidity Staking tests", () => {
   before("Setting up gaugeV2", async () => {
     const signer = ethers.provider.getSigner();
-    const pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
+    pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
     userSigner = ethers.provider.getSigner(userAddr);
     governanceSigner = ethers.provider.getSigner(governanceAddr);
-    distributionSigner = ethers.provider.getSigner(distributionAddr);
+    [Luffy, Zoro, Sanji, Nami] = await ethers.getSigners();
 
     console.log("-- Sending gas cost to governance addr --");
     await signer.sendTransaction({
@@ -41,6 +42,13 @@ describe("Liquidity Staking tests", () => {
       value: ethers.BigNumber.from("10000000000000000000"),
       data: undefined,
     });
+
+    console.log("-- Sending gas cost to dillHolder addr --");
+    await signer.sendTransaction({
+      to: pickleHolder,
+      value: ethers.BigNumber.from("10000000000000000000"),
+      data: undefined,
+    });
     console.log("------------------------ sent ------------------------");
 
     /** unlock accounts */
@@ -49,11 +57,6 @@ describe("Liquidity Staking tests", () => {
       params: [governanceAddr],
     });
 
-    await hre.network.provider.request({
-      method: "evm_unlockUnknownAccount",
-      params: [distributionAddr],
-    });
-
     await hre.network.provider.request({
       method: "evm_unlockUnknownAccount",
       params: [userAddr],
@@ -63,7 +66,7 @@ describe("Liquidity Staking tests", () => {
       method: "evm_unlockUnknownAccount",
       params: [dillHolder],
     });
-    [Luffy, Zoro, Sanji] = await ethers.getSigners();
+
     await hre.network.provider.request({
       method: "evm_unlockUnknownAccount",
       params: [pickleHolder],
@@ -72,8 +75,8 @@ describe("Liquidity Staking tests", () => {
     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", distributionSigner);
-    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr);
+    const gaugeV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeV2", pickleHolderSigner);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, ['PICKLE'], [pickleAddr]);
     await GaugeV2.deployed();
     thisContractAddr = GaugeV2.address;
     console.log("GaugeV2 deployed to:", thisContractAddr);
@@ -82,16 +85,17 @@ describe("Liquidity Staking tests", () => {
     const pickleFromHolder = pickle.connect(pickleHolderSigner);
 
     console.log("------------------------ Depositing pickle ------------------------");
-    await pickleFromHolder.transfer(distributionAddr, ethers.utils.parseEther("100"));
     await pickleFromHolder.transfer(dillHolder, ethers.utils.parseEther("50"));
     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, {gasLimit: 9000000})).to.be.revertedWith(
+    await expect(GaugeFromUser.depositAllAndLock(8640, false, {gasLimit: 9000000})).to.be.revertedWith(
       "Minimum stake time not met"
     );
   });
@@ -99,7 +103,7 @@ describe("Liquidity Staking tests", () => {
   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, {gasLimit: 9000000})).to.be.revertedWith(
+    await expect(GaugeFromUser.depositAllAndLock(86400 * 366, false, {gasLimit: 9000000})).to.be.revertedWith(
       "Trying to lock for too long"
     );
   });
@@ -107,7 +111,7 @@ describe("Liquidity Staking tests", () => {
   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, {gasLimit: 9000000})).to.be.revertedWith(
+    await expect(GaugeFromUser.depositAndLock(0, 86400 * 360, false, {gasLimit: 9000000})).to.be.revertedWith(
       "Cannot stake 0"
     );
   });
@@ -124,7 +128,7 @@ describe("Liquidity Staking tests", () => {
     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, {
+    await GaugeFromUser.depositAndLock(ethers.utils.parseEther("10"), 86400 * 365, false, {
       gasLimit: 9000000,
     });
 
@@ -140,22 +144,22 @@ describe("Liquidity Staking tests", () => {
 
   it("notifyRewardAmount should fail when called by other than distribution ", async () => {
     const bal = await pickle.balanceOf(thisContractAddr);
-    await pickle.connect(distributionSigner).approve(thisContractAddr, 0);
-    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
-    await expect(GaugeFromUser.notifyRewardAmount(bal, {gasLimit: 9000000})).to.be.revertedWith(
+    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"
     );
   });
 
   it("Should get reward amount successfully", async () => {
     const bal = await pickle.balanceOf(thisContractAddr);
-    await pickle.connect(distributionSigner).approve(thisContractAddr, 0);
-    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
 
-    await GaugeV2.notifyRewardAmount(bal, {
+    await GaugeV2.notifyRewardAmount([bal], {
       gasLimit: 9000000,
     });
-    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRate())));
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
     advanceNDays(200);
 
     console.log("--------------------------------------------------------------------------------------");
@@ -207,15 +211,15 @@ describe("Liquidity Staking tests", () => {
     );
   });
 
-  it("Should test deposit, deposit and lock and get reward successfully", async () => {
+  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("===================================================================================================");
 
-    const fivePickle = ethers.utils.parseEther("5");
     const dillHolderSigner = ethers.provider.getSigner(dillHolder);
 
     const gaugeFromDillHolder = GaugeV2.connect(dillHolderSigner);
@@ -232,7 +236,7 @@ describe("Liquidity Staking tests", () => {
     // Deposit and Lock - dillHolder
     await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
     await pickle.connect(dillHolderSigner).approve(thisContractAddr, fivePickle);
-    await gaugeFromDillHolder.depositAndLock(fivePickle, 86400 * 365, {gasLimit: 9000000});
+    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)))
@@ -251,7 +255,7 @@ describe("Liquidity Staking tests", () => {
     // Deposit and Lock - Luffy
     await pickle.connect(Luffy).approve(thisContractAddr, 0);
     await pickle.connect(Luffy).approve(thisContractAddr, fivePickle);
-    await gaugeFromLuffy.depositAndLock(fivePickle, 86400 * 365, {gasLimit: 9000000});
+    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)))
@@ -273,19 +277,28 @@ describe("Liquidity Staking tests", () => {
     // 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, {gasLimit: 9000000});
+    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(distributionSigner).approve(thisContractAddr, 0);
-    await pickle.connect(distributionSigner).approve(thisContractAddr, bal);
-    await GaugeV2.notifyRewardAmount(bal, {
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
+    await GaugeV2.notifyRewardAmount([bal], {
       gasLimit: 9000000,
     });
-    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRate())));
+    console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
     console.log("--------------------------------------------------------------------------------------");
     advanceNDays(365);
 
@@ -327,6 +340,14 @@ describe("Liquidity Staking tests", () => {
       "Sanji's pickle balance after getting reward and withdrawing deposit (deposit & lock)",
       Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
     );
+
+    //getReward Nami (permanent lock)
+    console.log(await GaugeV2.lockedStakesOf(Nami.address));
+    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("--------------------------------------------------------------------------------------");
   });
 
@@ -360,7 +381,7 @@ describe("Liquidity Staking tests", () => {
     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, {
+    await GaugeFromUser.depositAndLock(ethers.utils.parseEther("0.03"), 86400 * 365, false, {
       gasLimit: 9000000,
     });
     const userBalAfterDeposit = await pickle.balanceOf(userAddr);
@@ -378,4 +399,4 @@ describe("Liquidity Staking tests", () => {
 
     await GaugeFromUser.exit({gasLimit: 9000000});
   });
-});
+});
\ No newline at end of file
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..0e6982eb4
--- /dev/null
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -0,0 +1,248 @@
+const {advanceNDays, advanceSevenDays} = 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.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(
+    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, 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 365 days
+    await GaugeV2BydillHolder.depositAndLock(tenPickles, 365 * 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("dillHolder", GaugeV2BydillHolder, dillHolderAddr);
+
+    // 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 Zoro much after stake lock expired where zoro never claimed his reward before
+    await getAndPrintReward("Zoro", GaugeV2ByZoro, Zoro.address);
+  });
+});

From 45f1f37df463dc5663650328cca54e27605f9278 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 28 Jun 2022 18:28:57 +0530
Subject: [PATCH 42/55] feat: virtual gauge proxy

---
 src/dill/gauge-proxy-v2.sol | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 5bde86375..82fa76a2f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1072,6 +1072,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // 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
@@ -1312,7 +1313,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     // Add new token gauge
-    function addGauge(address _token) external {
+    function addGauge(address _token, bool _isVirtual) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] == address(0x0), "exists");
 
@@ -1327,6 +1328,15 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         _tokens.push(_token);
     }
 
+    function addVirtualGauge(address _token, address _jar) external {
+        require(msg.sender == governance, "!gov");
+        require(gauges[_token] == address(0x0), "exists");
+        address vgauge= address(new VirtualGauge(_token, _jar, msg.sender));
+        gauges[_token] = vgauge;
+        isVirtual[vgauge] = true;
+        _tokens.push(_token);
+    }
+
     function delistGauge(address _token) external {
         require(msg.sender == governance, "!gov");
         require(gauges[_token] != address(0x0), "!exists");

From 086d1e581b22a5174e3de9bc2f10abbad19532cd Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 28 Jun 2022 23:43:53 +0530
Subject: [PATCH 43/55] fix: remove mapping entry  from is_virtual_gauge

---
 src/dill/gauge-proxy-v2.sol | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 82fa76a2f..f58e856b1 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1347,9 +1347,11 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         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);
 

From 7c14e12d12332ecfcfaeed4bfac1e756f1402156 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 30 Jun 2022 13:15:27 +0530
Subject: [PATCH 44/55] feat: gauge proxy with gauge middleware to support
 updating of versioned gauge contracts

---
 src/dill/gauge-middleware.sol | 54 +++++++++++++++++++++++++++++++++++
 src/dill/gauge-proxy-v2.sol   | 35 ++++++++++++++++++-----
 2 files changed, 82 insertions(+), 7 deletions(-)
 create mode 100644 src/dill/gauge-middleware.sol

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
new file mode 100644
index 000000000..38f6a5244
--- /dev/null
+++ b/src/dill/gauge-middleware.sol
@@ -0,0 +1,54 @@
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+import {VirtualGauge, Gauge, ProtocolGovernance} from "./gauge-proxy-v2.sol";
+
+contract GaugeMiddleware is 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 != address(0),
+            "_governance 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 gaugeProxy");
+        gaugeProxy = _newgaugeProxy;
+    }
+
+    function addGauge(address _token) 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 Gauge(_token));
+    }
+
+    function addVirtualGauge(
+        address _token,
+        address _jar,
+        address _governance
+    ) external returns (address) {
+        require(msg.sender == gaugeProxy, "can only be called by gaugeProxy");
+        require(_token != address(0), "address of token cannot be zero");
+        require(_jar != address(0), "address of jar cannot be zero");
+        require(
+            _governance != address(0),
+            "address of governance cannot be zero"
+        );
+        return address(new VirtualGauge(_token, _jar, _governance));
+    }
+}
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index f58e856b1..6c0567baa 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.1;
 
+
 library Address {
     function isContract(address account) internal view returns (bool) {
         bytes32 codehash;
@@ -59,6 +60,17 @@ interface IERC20 {
     ) external returns (bool);
 }
 
+interface IGaugeMiddleware {
+    function addGauge(address _token) external returns (address);
+
+    function addVirtualGauge(
+        address _token,
+        address _jar,
+        address _governance
+    ) external returns (address);
+}
+
+
 library SafeERC20 {
     using Address for address;
 
@@ -1088,6 +1100,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     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
 
     struct delegateData {
         // delegated address
@@ -1130,6 +1143,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         periodForDistribute[1] = 1;
     }
 
+    function addGaugeMiddleware(address _gaugeMiddleware) external  {
+        require(_gaugeMiddleware != address(0), "gaugeMiddleware cannot set to zero")
+        require(_gaugeMiddleware != gaugeMiddleware, "current and new gaugeMiddleware are same");
+        gaugeMiddleware = IGaugeMiddleware(_gaugeMiddleware);
+    }
+
     // Reset votes to 0
     function reset() external {
         uint256 currentId = getCurrentPeriodId();
@@ -1313,25 +1332,27 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     // Add new token gauge
-    function addGauge(address _token, bool _isVirtual) external {
+    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] = _token;
-
-        gauges[_token] = address(
-            new GaugeV2(_token, governance, _rewardSymbols, _rewardTokens)
-        );
+        gauges[_token] = gaugeMiddleware.addGauge(_token, governance, _rewardSymbols, _rewardTokens);
         _tokens.push(_token);
     }
 
     function addVirtualGauge(address _token, address _jar) external {
         require(msg.sender == governance, "!gov");
+        require(address(gaugeMiddleware) != address(0), "cannot add new gauge without initializing gaugeMiddleware");
         require(gauges[_token] == address(0x0), "exists");
-        address vgauge= address(new VirtualGauge(_token, _jar, msg.sender));
+        string[] memory _rewardSymbols = new string[](1);
+        address[] memory _rewardTokens = new address[](1);
+        _rewardSymbols[0] = "PICKLE";
+        _rewardTokens[0] = _token;
+        address vgauge = gaugeMiddleware.addVirtualGauge(_jar, governance,  _rewardSymbols, _rewardTokens);
         gauges[_token] = vgauge;
         isVirtual[vgauge] = true;
         _tokens.push(_token);

From 52e374613fc7262f8d560bf8af2f2350af8c44dd Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 1 Jul 2022 20:44:38 +0530
Subject: [PATCH 45/55] feat: add virtual gauge

---
 src/dill/gauge-middleware.sol |  29 +-
 src/dill/gauge-proxy-v2.sol   | 543 +++++++++++++++++++++++++++++++++-
 2 files changed, 563 insertions(+), 9 deletions(-)

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index 38f6a5244..d9fd3a1f4 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -1,7 +1,7 @@
 pragma solidity >=0.8.0;
 
 import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
-import {VirtualGauge, Gauge, ProtocolGovernance} from "./gauge-proxy-v2.sol";
+import {GaugeV2, ProtocolGovernance, VirtualGaugeV2} from "./gauge-proxy-v2.sol";
 
 contract GaugeMiddleware is Initializable {
     address public gaugeProxy;
@@ -31,16 +31,25 @@ contract GaugeMiddleware is Initializable {
         gaugeProxy = _newgaugeProxy;
     }
 
-    function addGauge(address _token) external returns (address) {
+    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 Gauge(_token));
+        return
+            address(
+                new GaugeV2(_token, _governance, _rewardSymbols, _rewardTokens)
+            );
     }
 
     function addVirtualGauge(
-        address _token,
         address _jar,
-        address _governance
+        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");
@@ -49,6 +58,14 @@ contract GaugeMiddleware is Initializable {
             _governance != address(0),
             "address of governance cannot be zero"
         );
-        return address(new VirtualGauge(_token, _jar, _governance));
+        return
+            address(
+                new VirtualGaugeV2(
+                    _jar,
+                    _governance,
+                    _rewardSymbols,
+                    _rewardTokens
+                )
+            );
     }
 }
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 6c0567baa..c4a1df2f8 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -64,9 +64,9 @@ interface IGaugeMiddleware {
     function addGauge(address _token) external returns (address);
 
     function addVirtualGauge(
-        address _token,
         address _jar,
-        address _governance
+        address _governance,
+
     ) external returns (address);
 }
 
@@ -273,6 +273,542 @@ contract ProtocolGovernance {
     }
 }
 
+interface IJar {
+    function balanceOf(address account) external view returns (uint256);
+    function totalSupply() external view returns (uint256);
+}
+
+contract VirtualBalanceWrapper {
+    IJar public jar;
+
+    function totalSupply() external view returns (uint256) {
+        return jar.totalSupply();
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return jar.balanceOf(account);
+    }
+}
+
+contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWrapper {
+    // 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; // 6 decimals of precision. 1x = 1000000
+        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]);
+        _;
+    }
+
+    /* ========== CONSTRUCTOR ========== */
+
+    constructor(
+        address _jar,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
+    ) {
+        require(_jar == address(0), "cannot set zero address");
+        jar = IJar(_jar);
+        rewardTokens = _rewardTokens;
+        rewardSymbols = _rewardSymbols;
+
+        DISTRIBUTION = msg.sender;
+        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 jar, bool value) external onlyGov {
+        require(authorisedAddress[_jar] != value, "address is already set to given value");
+        authorisedAddress[_jar] = 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 nonReentrant updateReward(account, false) onlyJarAndAuthorised returns(uint256) {
+        uint256 amount;
+        for (uint256 i = 0; i < _lockedStakes[account].length; i++) {
+            LockedStake memory thisStake = _lockedStakes[account][i];
+            if (
+                thisStake.liquidity > 0 &&
+                (stakesUnlocked ||
+                    stakesUnlockedForAccount[account] ||
+                    (!thisStake.isPermanentlyLocked &&
+                        block.timestamp >= thisStake.ending_timestamp))
+            ) {
+                delete _lockedStakes[account][i];
+                amount += thisStake.liquidity;
+            }
+        }
+        if (amount > 0) {
+            emit WithdrawnAll(account, amount);
+        }
+        return amount;
+    }
+
+    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 {
+        uint256 reward;
+        // _lastRewardClaimTime[account] = block.timestamp;
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            reward = _rewards[account][i];
+            if (reward > 0) {
+                _rewards[account][i] = 0;
+                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 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;
 
@@ -1352,7 +1888,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
         _rewardTokens[0] = _token;
-        address vgauge = gaugeMiddleware.addVirtualGauge(_jar, governance,  _rewardSymbols, _rewardTokens);
+        address vgauge = gaugeMiddleware.
+        (_jar, governance,  _rewardSymbols, _rewardTokens);
         gauges[_token] = vgauge;
         isVirtual[vgauge] = true;
         _tokens.push(_token);

From 1b3b6713a105466b2192731bd5d7f6f840197038 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 1 Jul 2022 20:47:57 +0530
Subject: [PATCH 46/55] feat: update Interface gauge middleware

---
 src/dill/gauge-proxy-v2.sol | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index c4a1df2f8..1c83377dc 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -61,11 +61,16 @@ interface IERC20 {
 }
 
 interface IGaugeMiddleware {
-    function addGauge(address _token) external returns (address);
+    function addGauge(address _token,
+        address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens) external returns (address);
 
     function addVirtualGauge(
         address _jar,
         address _governance,
+        string[] memory _rewardSymbols,
+        address[] memory _rewardTokens
 
     ) external returns (address);
 }

From a9abe2c386b6e469c608732a945e5ac40d945ac2 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Mon, 4 Jul 2022 17:30:50 +0530
Subject: [PATCH 47/55] fix:minor fixes

---
 src/dill/gauge-middleware.sol | 68 +++++++++++++++++++++++++++++++++--
 src/dill/gauge-proxy-v2.sol   | 22 ++++++------
 2 files changed, 76 insertions(+), 14 deletions(-)

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index d9fd3a1f4..db46203d0 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -1,9 +1,72 @@
 pragma solidity >=0.8.0;
 
-import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+// import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+/**
+ * @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;
+}
 import {GaugeV2, ProtocolGovernance, VirtualGaugeV2} from "./gauge-proxy-v2.sol";
 
-contract GaugeMiddleware is Initializable {
+contract GaugeMiddleware is Initializable, ProtocolGovernance {
     address public gaugeProxy;
 
     function initialize(address _gaugeProxy, address _governance)
@@ -52,7 +115,6 @@ contract GaugeMiddleware is Initializable {
         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");
         require(_jar != address(0), "address of jar cannot be zero");
         require(
             _governance != address(0),
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 1c83377dc..5f6af29a3 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -286,16 +286,17 @@ interface IJar {
 contract VirtualBalanceWrapper {
     IJar public jar;
 
-    function totalSupply() external view returns (uint256) {
+    function totalSupply() public view returns (uint256) {
         return jar.totalSupply();
     }
 
-    function balanceOf(address account) external view returns (uint256) {
+    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);
@@ -525,9 +526,9 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
 
     }
 
-    function setAuthoriseAddress(address jar, bool value) external onlyGov {
-        require(authorisedAddress[_jar] != value, "address is already set to given value");
-        authorisedAddress[_jar] = value;
+    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) {
@@ -1641,7 +1642,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     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
+    IGaugeMiddleware public gaugeMiddleware;
 
     struct delegateData {
         // delegated address
@@ -1685,8 +1686,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     }
 
     function addGaugeMiddleware(address _gaugeMiddleware) external  {
-        require(_gaugeMiddleware != address(0), "gaugeMiddleware cannot set to zero")
-        require(_gaugeMiddleware != gaugeMiddleware, "current and new gaugeMiddleware are same");
+        require(_gaugeMiddleware != address(0), "gaugeMiddleware cannot set to zero");
+        require(_gaugeMiddleware != address(gaugeMiddleware), "current and new gaugeMiddleware are same");
         gaugeMiddleware = IGaugeMiddleware(_gaugeMiddleware);
     }
 
@@ -1893,10 +1894,9 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
         _rewardTokens[0] = _token;
-        address vgauge = gaugeMiddleware.
-        (_jar, governance,  _rewardSymbols, _rewardTokens);
+        address vgauge = gaugeMiddleware.addVirtualGauge(_jar, governance,  _rewardSymbols, _rewardTokens);
         gauges[_token] = vgauge;
-        isVirtual[vgauge] = true;
+        isVirtualGauge[vgauge] = true;
         _tokens.push(_token);
     }
 

From 81c672b1fc1b786ff9237a042c2428d97143baaf Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 1 Jul 2022 18:46:40 +0530
Subject: [PATCH 48/55] fix: change reward claim time

---
 src/tests/dill/06_GaugeV2_situtational.test.js | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/tests/dill/06_GaugeV2_situtational.test.js b/src/tests/dill/06_GaugeV2_situtational.test.js
index 0e6982eb4..f2afef29e 100644
--- a/src/tests/dill/06_GaugeV2_situtational.test.js
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -190,8 +190,8 @@ describe("Liquidity Staking tests", () => {
 
     await getAndPrintReward("Nami", GaugeV2ByNami, Nami.address); // get reward by Nami before expiry
 
-    // DepositAndLock with dill balance(start time + 65 days) for 365 days
-    await GaugeV2BydillHolder.depositAndLock(tenPickles, 365 * 86400, false);
+    // 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) =>",
@@ -231,7 +231,7 @@ describe("Liquidity Staking tests", () => {
     }
     await getAndPrintReward("Nami", GaugeV2ByNami, Nami.address); // Nami claims reward after stake expiry
 
-    await getAndPrintReward("dillHolder", GaugeV2BydillHolder, dillHolderAddr);
+    await getAndPrintReward("Zoro", GaugeV2ByZoro, Zoro.address);
 
     // Advancing 21 weeks (1 year from start time)
     for (let i = 0; i < 21; i++) {
@@ -242,7 +242,14 @@ describe("Liquidity Staking tests", () => {
     // 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 Zoro much after stake lock expired where zoro never claimed his reward before
-    await getAndPrintReward("Zoro", GaugeV2ByZoro, Zoro.address);
+    // claim reward by dillHolder much after stake lock expired where dillHolder never claimed his reward before
+    await getAndPrintReward("dillHolder", GaugeV2BydillHolder, dillHolderAddr);
+    
   });
+  it.only("advance 7 days", async () => {
+    advanceNDays(7);
+    await pickle.connect(Luffy).approve(thisContractAddr, ethers.utils.parseEther("20"));
+    await GaugeV2ByLuffy.depositAndLock(tenPickles, 365 * 86400, false);
+  })
 });
+

From af5d04bbb169bb466f0934034c718e64cc4ac0c2 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 7 Jul 2022 12:57:36 +0530
Subject: [PATCH 49/55] feat: partial withdrawal

---
 src/dill/gauge-middleware.sol |  73 +-----------
 src/dill/gauge-proxy-v2.sol   | 213 ++++++++++++++++++++++++++--------
 2 files changed, 165 insertions(+), 121 deletions(-)

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index db46203d0..0736537a3 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -1,72 +1,9 @@
+// SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-// import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
-/**
- * @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;
+import {GaugeV2, Initializable, ProtocolGovernance, VirtualGaugeV2} from "./gauge-proxy-v2.sol";
 
-    /**
-     * @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;
-}
-import {GaugeV2, ProtocolGovernance, VirtualGaugeV2} from "./gauge-proxy-v2.sol";
-
-contract GaugeMiddleware is Initializable, ProtocolGovernance {
+contract GaugeMiddleware is ProtocolGovernance, Initializable {
     address public gaugeProxy;
 
     function initialize(address _gaugeProxy, address _governance)
@@ -77,10 +14,6 @@ contract GaugeMiddleware is Initializable, ProtocolGovernance {
             _gaugeProxy != address(0),
             "_gaugeProxy address cannot be set to zero"
         );
-        require(
-            _governance != address(0),
-            "_governance address cannot be set to zero"
-        );
         require(
             _governance != _gaugeProxy,
             "_governance address and _gaugeProxy cannot be same"
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 5f6af29a3..691ad9c25 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.1;
 
-
 library Address {
     function isContract(address account) internal view returns (bool) {
         bytes32 codehash;
@@ -61,21 +60,21 @@ interface IERC20 {
 }
 
 interface IGaugeMiddleware {
-    function addGauge(address _token,
+    function addGauge(
+        address _token,
         address _governance,
         string[] memory _rewardSymbols,
-        address[] memory _rewardTokens) external returns (address);
+        address[] memory _rewardTokens
+    ) external returns (address);
 
     function addVirtualGauge(
         address _jar,
         address _governance,
         string[] memory _rewardSymbols,
         address[] memory _rewardTokens
-
     ) external returns (address);
 }
 
-
 library SafeERC20 {
     using Address for address;
 
@@ -280,6 +279,7 @@ contract ProtocolGovernance {
 
 interface IJar {
     function balanceOf(address account) external view returns (uint256);
+
     function totalSupply() external view returns (uint256);
 }
 
@@ -295,7 +295,11 @@ contract VirtualBalanceWrapper {
     }
 }
 
-contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWrapper {
+contract VirtualGaugeV2 is
+    ProtocolGovernance,
+    ReentrancyGuard,
+    VirtualBalanceWrapper
+{
     using SafeERC20 for IERC20;
     // Token addresses
     IERC20 public constant DILL =
@@ -349,7 +353,7 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
         uint256 start_timestamp;
         uint256 liquidity;
         uint256 ending_timestamp;
-        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+        uint256 lock_multiplier;
         bool isPermanentlyLocked;
     }
 
@@ -523,11 +527,16 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
         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");
+    function setAuthoriseAddress(address _account, bool value)
+        external
+        onlyGov
+    {
+        require(
+            authorisedAddress[_account] != value,
+            "address is already set to given value"
+        );
         authorisedAddress[_account] = value;
     }
 
@@ -607,7 +616,10 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
         derivedSupply = derivedSupply + _derivedBalance;
     }
 
-    function depositFor(uint256 amount, address account) external onlyJarAndAuthorised {
+    function depositFor(uint256 amount, address account)
+        external
+        onlyJarAndAuthorised
+    {
         _deposit(amount, account, 0, block.timestamp, false);
     }
 
@@ -648,36 +660,77 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
         emit Staked(account, amount, secs, _lockedStakes[account].length - 1);
     }
 
-    function withdraw(address account, uint256 index) external onlyJarAndAuthorised returns(uint256) {
+    function withdraw(address account, uint256 index)
+        external
+        onlyJarAndAuthorised
+        returns (uint256)
+    {
         return _withdraw(account, index);
     }
 
-    function withdrawAll(address account) public nonReentrant updateReward(account, false) onlyJarAndAuthorised returns(uint256) {
-        uint256 amount;
-        for (uint256 i = 0; i < _lockedStakes[account].length; i++) {
-            LockedStake memory thisStake = _lockedStakes[account][i];
+    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
             if (
                 thisStake.liquidity > 0 &&
                 (stakesUnlocked ||
-                    stakesUnlockedForAccount[account] ||
+                    stakesUnlockedForAccount[_account] ||
                     (!thisStake.isPermanentlyLocked &&
                         block.timestamp >= thisStake.ending_timestamp))
             ) {
-                delete _lockedStakes[account][i];
-                amount += thisStake.liquidity;
+                if (thisStake.liquidity < (_amount - amountToTransfer)) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                } else if (
+                    thisStake.liquidity == (_amount - amountToTransfer)
+                ) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                    break;
+                } else if (thisStake.liquidity > (_amount - amountToTransfer)) {
+                    _lockedStakes[_account][i].liquidity -= _amount;
+                    amountToTransfer += _amount;
+                    break;
+                }
             }
         }
-        if (amount > 0) {
-            emit WithdrawnAll(account, amount);
-        }
-        return amount;
+        return amountToTransfer;
     }
 
     function _withdraw(address account, uint256 index)
         internal
         nonReentrant
         updateReward(account, false)
-        returns(uint256)
+        returns (uint256)
     {
         LockedStake memory thisStake;
         require(index < _lockedStakes[account].length, "Stake not found");
@@ -702,9 +755,13 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
         return thisStake.liquidity;
     }
 
-    function getReward(address account) public nonReentrant updateReward(account, true) onlyJarAndAuthorised {
+    function getReward(address account)
+        public
+        nonReentrant
+        updateReward(account, true)
+        onlyJarAndAuthorised
+    {
         uint256 reward;
-        // _lastRewardClaimTime[account] = block.timestamp;
 
         for (uint256 i = 0; i < rewardTokens.length; i++) {
             reward = _rewards[account][i];
@@ -810,6 +867,7 @@ contract VirtualGaugeV2 is ProtocolGovernance, ReentrancyGuard, VirtualBalanceWr
     );
     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);
@@ -879,7 +937,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         uint256 start_timestamp;
         uint256 liquidity;
         uint256 ending_timestamp;
-        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+        uint256 lock_multiplier;
         bool isPermanentlyLocked;
     }
 
@@ -1237,28 +1295,59 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         _withdraw(index);
     }
 
-    function withdrawAll() public nonReentrant updateReward(msg.sender, false) {
-        uint256 amount;
-        for (uint256 i = 0; i < _lockedStakes[msg.sender].length; i++) {
-            LockedStake memory thisStake = _lockedStakes[msg.sender][i];
-            uint256 liquidity = thisStake.liquidity;
+    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
             if (
-                liquidity > 0 &&
+                thisStake.liquidity > 0 &&
                 (stakesUnlocked ||
-                    stakesUnlockedForAccount[msg.sender] ||
+                    stakesUnlockedForAccount[_account] ||
                     (!thisStake.isPermanentlyLocked &&
                         block.timestamp >= thisStake.ending_timestamp))
             ) {
-                _totalSupply = _totalSupply - liquidity;
-                _balances[msg.sender] = _balances[msg.sender] - liquidity;
-                delete _lockedStakes[msg.sender][i];
-                amount += liquidity;
+                if (thisStake.liquidity < (_amount - amountToTransfer)) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                } else if (
+                    thisStake.liquidity == (_amount - amountToTransfer)
+                ) {
+                    amountToTransfer += thisStake.liquidity;
+                    delete _lockedStakes[_account][i];
+                    break;
+                } else if (thisStake.liquidity > (_amount - amountToTransfer)) {
+                    _lockedStakes[_account][i].liquidity -= _amount;
+                    amountToTransfer += _amount;
+                    break;
+                }
             }
         }
-        if (amount > 0) {
-            TOKEN.safeTransfer(msg.sender, amount);
-            emit WithdrawnAll(msg.sender, amount);
+        if (amountToTransfer > 0) {
+            _totalSupply = _totalSupply - amountToTransfer;
+            _balances[_account] = _balances[_account] - amountToTransfer;
+            TOKEN.safeTransfer(msg.sender, amountToTransfer);
         }
+        return amountToTransfer;
     }
 
     function _withdraw(uint256 index)
@@ -1402,6 +1491,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     );
     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);
@@ -1516,7 +1606,7 @@ contract MasterDill {
             amount <= spenderAllowance,
             "transferFrom: exceeds spender allowance"
         );
-        
+
         if (spender != src && spenderAllowance != type(uint256).max) {
             uint256 newAllowance = spenderAllowance - amount;
             allowances[src][spender] = newAllowance;
@@ -1685,9 +1775,15 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         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");
+    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);
     }
 
@@ -1876,25 +1972,41 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // 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(
+            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] = _token;
-        gauges[_token] = gaugeMiddleware.addGauge(_token, governance, _rewardSymbols, _rewardTokens);
+        gauges[_token] = gaugeMiddleware.addGauge(
+            _token,
+            governance,
+            _rewardSymbols,
+            _rewardTokens
+        );
         _tokens.push(_token);
     }
 
     function addVirtualGauge(address _token, address _jar) external {
         require(msg.sender == governance, "!gov");
-        require(address(gaugeMiddleware) != address(0), "cannot add new gauge without initializing gaugeMiddleware");
+        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] = _token;
-        address vgauge = gaugeMiddleware.addVirtualGauge(_jar, governance,  _rewardSymbols, _rewardTokens);
+        address vgauge = gaugeMiddleware.addVirtualGauge(
+            _jar,
+            governance,
+            _rewardSymbols,
+            _rewardTokens
+        );
         gauges[_token] = vgauge;
         isVirtualGauge[vgauge] = true;
         _tokens.push(_token);
@@ -1910,11 +2022,10 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         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);
 

From 3c22a4ca79de82182345604d94a34dd40c7c616f Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Thu, 7 Jul 2022 18:56:39 +0530
Subject: [PATCH 50/55] fix: seprate gaugeMiddlewares for both normal and
 virtual gauge

---
 src/dill/gauge-middleware.sol | 27 ++++++++++++++++++++++++++-
 src/dill/gauge-proxy-v2.sol   | 23 +++++++++++++++++++++--
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index 0736537a3..ea223c3fb 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -40,6 +40,31 @@ contract GaugeMiddleware is ProtocolGovernance, Initializable {
                 new GaugeV2(_token, _governance, _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 gaugeProxy");
+        gaugeProxy = _newgaugeProxy;
+    }
 
     function addVirtualGauge(
         address _jar,
@@ -63,4 +88,4 @@ contract GaugeMiddleware is ProtocolGovernance, Initializable {
                 )
             );
     }
-}
+}
\ No newline at end of file
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 691ad9c25..d7091108e 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -66,7 +66,9 @@ interface IGaugeMiddleware {
         string[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) external returns (address);
+}
 
+interface IVirtualGaugeMiddleware {
     function addVirtualGauge(
         address _jar,
         address _governance,
@@ -1733,6 +1735,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     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
@@ -1787,6 +1790,22 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         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();
@@ -1990,6 +2009,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         _tokens.push(_token);
     }
 
+    // Add new token virtual gauge
     function addVirtualGauge(address _token, address _jar) external {
         require(msg.sender == governance, "!gov");
         require(
@@ -2001,7 +2021,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
         _rewardTokens[0] = _token;
-        address vgauge = gaugeMiddleware.addVirtualGauge(
+        address vgauge = virtualGaugeMiddleware.addVirtualGauge(
             _jar,
             governance,
             _rewardSymbols,
@@ -2125,7 +2145,6 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
                 distributed[distributionId][i] = true;
             }
         }
-
         if (_tokens.length == _end) {
             distributionId += 1;
         }

From 1ee6fe1a674900d326a739aee8eaa5955d2a1b11 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 8 Jul 2022 15:59:58 +0530
Subject: [PATCH 51/55] fix: minor fix

---
 src/dill/gauge-proxy-v2.sol                   | 26 +++---
 .../dill/05_gaugeV2_liquidityLocking.test.js  | 81 +++++++++++++++----
 .../dill/06_GaugeV2_situtational.test.js      |  7 --
 3 files changed, 79 insertions(+), 35 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index d7091108e..92cf99cc1 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -702,6 +702,7 @@ contract VirtualGaugeV2 is
         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 ||
@@ -709,18 +710,16 @@ contract VirtualGaugeV2 is
                     (!thisStake.isPermanentlyLocked &&
                         block.timestamp >= thisStake.ending_timestamp))
             ) {
-                if (thisStake.liquidity < (_amount - amountToTransfer)) {
+                if (thisStake.liquidity < amountRemaining) {
                     amountToTransfer += thisStake.liquidity;
                     delete _lockedStakes[_account][i];
-                } else if (
-                    thisStake.liquidity == (_amount - amountToTransfer)
-                ) {
+                } else if (thisStake.liquidity == amountRemaining) {
                     amountToTransfer += thisStake.liquidity;
                     delete _lockedStakes[_account][i];
                     break;
-                } else if (thisStake.liquidity > (_amount - amountToTransfer)) {
-                    _lockedStakes[_account][i].liquidity -= _amount;
-                    amountToTransfer += _amount;
+                } else if (thisStake.liquidity > amountRemaining) {
+                    _lockedStakes[_account][i].liquidity -= amountRemaining;
+                    amountToTransfer = _amount;
                     break;
                 }
             }
@@ -1321,6 +1320,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         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 ||
@@ -1328,18 +1328,16 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
                     (!thisStake.isPermanentlyLocked &&
                         block.timestamp >= thisStake.ending_timestamp))
             ) {
-                if (thisStake.liquidity < (_amount - amountToTransfer)) {
+                if (thisStake.liquidity < amountRemaining) {
                     amountToTransfer += thisStake.liquidity;
                     delete _lockedStakes[_account][i];
-                } else if (
-                    thisStake.liquidity == (_amount - amountToTransfer)
-                ) {
+                } else if (thisStake.liquidity == amountRemaining) {
                     amountToTransfer += thisStake.liquidity;
                     delete _lockedStakes[_account][i];
                     break;
-                } else if (thisStake.liquidity > (_amount - amountToTransfer)) {
-                    _lockedStakes[_account][i].liquidity -= _amount;
-                    amountToTransfer += _amount;
+                } else if (thisStake.liquidity > amountRemaining) {
+                    _lockedStakes[_account][i].liquidity -= amountRemaining;
+                    amountToTransfer = _amount;
                     break;
                 }
             }
diff --git a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
index 6135d8a47..b61f645d9 100644
--- a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -15,12 +15,29 @@ let userSigner,
   pickle,
   pickleHolderSigner,
   governanceSigner,
+  dillHolderSigner,
+  gaugeFromDillHolder,
   Luffy,
   Zoro,
   Sanji,
   Nami;
 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
+    );
+  });
+  console.log("*******************************************************************************");
+};
+
 describe("Liquidity Staking tests", () => {
   before("Setting up gaugeV2", async () => {
     const signer = ethers.provider.getSigner();
@@ -43,12 +60,6 @@ describe("Liquidity Staking tests", () => {
       data: undefined,
     });
 
-    console.log("-- Sending gas cost to dillHolder addr --");
-    await signer.sendTransaction({
-      to: pickleHolder,
-      value: ethers.BigNumber.from("10000000000000000000"),
-      data: undefined,
-    });
     console.log("------------------------ sent ------------------------");
 
     /** unlock accounts */
@@ -76,7 +87,7 @@ describe("Liquidity Staking tests", () => {
 
     console.log("-- Deploying Gaugev2 contract --");
     const gaugeV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeV2", pickleHolderSigner);
-    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, ['PICKLE'], [pickleAddr]);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, ["PICKLE"], [pickleAddr]);
     await GaugeV2.deployed();
     thisContractAddr = GaugeV2.address;
     console.log("GaugeV2 deployed to:", thisContractAddr);
@@ -84,8 +95,11 @@ describe("Liquidity Staking tests", () => {
     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("50"));
+    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"));
@@ -220,10 +234,6 @@ describe("Liquidity Staking tests", () => {
     console.log("Nami's pickle balance ", Number(ethers.utils.formatEther(await pickle.balanceOf(Nami.address))));
     console.log("===================================================================================================");
 
-    const dillHolderSigner = ethers.provider.getSigner(dillHolder);
-
-    const gaugeFromDillHolder = GaugeV2.connect(dillHolderSigner);
-
     // Deposit - dillHolder
     await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
     await pickle.connect(dillHolderSigner).approve(thisContractAddr, fivePickle);
@@ -341,8 +351,8 @@ describe("Liquidity Staking tests", () => {
       Number(ethers.utils.formatEther(await pickle.balanceOf(Sanji.address)))
     );
 
+    await printStakes(Nami.address);
     //getReward Nami (permanent lock)
-    console.log(await GaugeV2.lockedStakesOf(Nami.address));
     await GaugeV2.connect(Nami).getReward();
     console.log(
       "Nami's pickle balance after getting reward (2.5x because stakes are permanently locked)",
@@ -399,4 +409,47 @@ describe("Liquidity Staking tests", () => {
 
     await GaugeFromUser.exit({gasLimit: 9000000});
   });
-});
\ No newline at end of file
+
+  it("Test partial withdrawal", async () => {
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
+    await pickle.connect(dillHolderSigner).approve(thisContractAddr, ethers.utils.parseEther("25"));
+    console.log(" -- deposit 5 pickle -- ");
+    await gaugeFromDillHolder.deposit(fivePickle, {gasLimit: 9000000});
+    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});
+
+    await printStakes(dillHolder);
+    advanceSevenDays();
+
+    await expect(gaugeFromDillHolder.partialWithdrawal(ethers.utils.parseEther("50"))).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);
+
+    // withdraw all
+    console.log(" -- Withdrawing all unlocked stakes -- ");
+    await gaugeFromDillHolder.withdrawAll();
+    await printStakes(dillHolder);
+  });
+});
diff --git a/src/tests/dill/06_GaugeV2_situtational.test.js b/src/tests/dill/06_GaugeV2_situtational.test.js
index f2afef29e..8cb49a952 100644
--- a/src/tests/dill/06_GaugeV2_situtational.test.js
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -244,12 +244,5 @@ describe("Liquidity Staking tests", () => {
 
     // claim reward by dillHolder much after stake lock expired where dillHolder never claimed his reward before
     await getAndPrintReward("dillHolder", GaugeV2BydillHolder, dillHolderAddr);
-    
   });
-  it.only("advance 7 days", async () => {
-    advanceNDays(7);
-    await pickle.connect(Luffy).approve(thisContractAddr, ethers.utils.parseEther("20"));
-    await GaugeV2ByLuffy.depositAndLock(tenPickles, 365 * 86400, false);
-  })
 });
-

From c077a5249f3336a311539bb892e15b8c69a89e9f Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 12 Jul 2022 10:31:38 +0530
Subject: [PATCH 52/55] fix: distribution address for gauge contracts

---
 src/dill/gauge-middleware.sol                  | 11 +++++++++--
 src/dill/gauge-proxy-v2.sol                    | 14 ++++++++++----
 src/tests/dill/06_GaugeV2_situtational.test.js |  3 ++-
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index ea223c3fb..5797b49b3 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -37,7 +37,13 @@ contract GaugeMiddleware is ProtocolGovernance, Initializable {
         require(_token != address(0), "address of token cannot be zero");
         return
             address(
-                new GaugeV2(_token, _governance, _rewardSymbols, _rewardTokens)
+                new GaugeV2(
+                    _token,
+                    _governance,
+                    msg.sender,
+                    _rewardSymbols,
+                    _rewardTokens
+                )
             );
     }
 }
@@ -83,9 +89,10 @@ contract VirtualGaugeMiddleware is ProtocolGovernance, Initializable {
                 new VirtualGaugeV2(
                     _jar,
                     _governance,
+                    msg.sender,
                     _rewardSymbols,
                     _rewardTokens
                 )
             );
     }
-}
\ No newline at end of file
+}
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 92cf99cc1..5b79f9e2e 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -416,6 +416,7 @@ contract VirtualGaugeV2 is
     constructor(
         address _jar,
         address _governance,
+        address _distribution,
         string[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) {
@@ -424,7 +425,7 @@ contract VirtualGaugeV2 is
         rewardTokens = _rewardTokens;
         rewardSymbols = _rewardSymbols;
 
-        DISTRIBUTION = msg.sender;
+        DISTRIBUTION = _distribution;
         governance = _governance;
 
         for (uint256 i = 0; i < _rewardTokens.length; i++) {
@@ -994,6 +995,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     constructor(
         address _token,
         address _governance,
+        address _distribution,
         string[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) {
@@ -1002,7 +1004,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
         rewardTokens = _rewardTokens;
         rewardSymbols = _rewardSymbols;
 
-        DISTRIBUTION = msg.sender;
+        DISTRIBUTION = _distribution;
         governance = _governance;
 
         for (uint256 i = 0; i < _rewardTokens.length; i++) {
@@ -2133,8 +2135,12 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, reward_);
-
-                    GaugeV2(_gauge).notifyRewardAmount(rewardArr);
+                    
+                    if (isVirtualGauge[_gauge]) {
+                        VirtualGaugeV2(_gauge).notifyRewardAmount(rewardArr);
+                    } else {
+                        GaugeV2(_gauge).notifyRewardAmount(rewardArr);
+                    }
                 }
 
                 if (_reward < 0) {
diff --git a/src/tests/dill/06_GaugeV2_situtational.test.js b/src/tests/dill/06_GaugeV2_situtational.test.js
index 8cb49a952..b82f93888 100644
--- a/src/tests/dill/06_GaugeV2_situtational.test.js
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -2,6 +2,7 @@ const {advanceNDays, advanceSevenDays} = require("./testHelper");
 const hre = require("hardhat");
 const {ethers} = require("hardhat");
 const chalk = require("chalk");
+
 const governanceAddr = "0x9d074E37d408542FD38be78848e8814AFB38db17";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pickleHolder = "0x68759973357F5fB3e844802B3E9bB74317358bf7";
@@ -102,7 +103,7 @@ describe("Liquidity Staking tests", () => {
     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, tokenSymbols, rewardTokens);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, pickleHolder, tokenSymbols, rewardTokens);
 
     await GaugeV2.deployed();
 

From 95139b761f6ab047918629e2bdb8bbb01d2031e6 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Tue, 12 Jul 2022 13:16:31 +0530
Subject: [PATCH 53/55] feat: add gauge interface

---
 src/dill/gauge-proxy-v2.sol | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 5b79f9e2e..0357aa3b9 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -285,6 +285,10 @@ interface IJar {
     function totalSupply() external view returns (uint256);
 }
 
+interface iGaugeV2 {
+    function notifyRewardAmount(uint256[] memory rewards) external;
+}
+
 contract VirtualBalanceWrapper {
     IJar public jar;
 
@@ -2135,12 +2139,8 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
 
                     PICKLE.safeApprove(_gauge, 0);
                     PICKLE.safeApprove(_gauge, reward_);
-                    
-                    if (isVirtualGauge[_gauge]) {
-                        VirtualGaugeV2(_gauge).notifyRewardAmount(rewardArr);
-                    } else {
-                        GaugeV2(_gauge).notifyRewardAmount(rewardArr);
-                    }
+
+                    iGaugeV2(_gauge).notifyRewardAmount(rewardArr);
                 }
 
                 if (_reward < 0) {

From 7951809930090549b87a91a4e1631f65b76a5f43 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Fri, 15 Jul 2022 18:25:35 +0530
Subject: [PATCH 54/55] fix: fixed gaguge-proxy tests

---
 src/dill/gauge-proxy-v2.sol                   |  4 +-
 .../01_gaugeProxyV2_chunkDistTest.test.js     | 49 +++++++++++++------
 .../dill/02_gaugeProxyV2_periodizationTest.js | 19 ++++++-
 .../dill/03_gaugeProcyV2_delegationTest.js    | 35 +++++++++----
 .../dill/05_gaugeV2_liquidityLocking.test.js  |  2 +-
 5 files changed, 82 insertions(+), 27 deletions(-)

diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 0357aa3b9..4db3b9052 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -2003,7 +2003,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         string[] memory _rewardSymbols = new string[](1);
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
-        _rewardTokens[0] = _token;
+        _rewardTokens[0] = address(PICKLE);
         gauges[_token] = gaugeMiddleware.addGauge(
             _token,
             governance,
@@ -2024,7 +2024,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
         string[] memory _rewardSymbols = new string[](1);
         address[] memory _rewardTokens = new address[](1);
         _rewardSymbols[0] = "PICKLE";
-        _rewardTokens[0] = _token;
+        _rewardTokens[0] = address(PICKLE);
         address vgauge = virtualGaugeMiddleware.addVirtualGauge(
             _jar,
             governance,
diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
index 1193dcaaa..b11cfa8aa 100644
--- a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -30,6 +30,12 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
       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(
@@ -41,6 +47,7 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
 
     /** Deploy gaugeProxyV2 */
     console.log("-- Deploying GaugeProxy v2 contract --");
+
     const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
     GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
       initializer: "initialize",
@@ -51,23 +58,30 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
     const mDILLAddr = await GaugeProxyV2.TOKEN();
     console.log("-- Adding mDILL to MasterChef --");
 
-    populatedTx = await masterChef.populateTransaction.add(
-      5000000,
-      mDILLAddr,
-      false
-    );
+    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],
-    });
   });
 
   beforeEach(async () => {
@@ -114,7 +128,10 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
      * FIRST CHUNK DISTRIBUTION (successful)
      */
     console.log("-- Distributing first chunk (0,1) --");
-    await GaugeProxyV2.distribute(0, 1);
+    await GaugeProxyV2.distribute(0, 1, {
+      gasLimit: 900000,
+    });
+
     let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
     let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
 
@@ -134,8 +151,10 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
      * FIRST CHUNK DISTRIBUTION (fail)
      */
     console.log("Distributing first chunk(0, 1) again");
-    await GaugeProxyV2.distribute(0, 1);
-   
+    await GaugeProxyV2.distribute(0, 1, {
+      gasLimit: 900000,
+    });
+
     let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
     let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
 
@@ -161,7 +180,9 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
      * SECOND CHUNK DISTRIBUTION (successful)
      */
     console.log("--Distributing second chunk(0,2)--");
-    await GaugeProxyV2.distribute(1, 2);
+    await GaugeProxyV2.distribute(1, 2, {
+      gasLimit: 900000,
+    });
     let pickleGaugeAddr = await GaugeProxyV2.getGauge(pickleLP);
     let yvecrvGaugeAddr = await GaugeProxyV2.getGauge(pyveCRVETH);
 
diff --git a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
index 34f1b7a52..c258529f1 100644
--- a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
+++ b/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
@@ -9,7 +9,7 @@ const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
-let GaugeProxyV2, userSigner, populatedTx, masterChef ;
+let GaugeProxyV2, userSigner, populatedTx, masterChef;
 
 describe("Vote & Distribute", () => {
   before("Setting up gaugeProxyV2", async () => {
@@ -59,6 +59,22 @@ describe("Vote & Distribute", () => {
     );
     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);
 
@@ -73,6 +89,7 @@ describe("Vote & Distribute", () => {
     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()));
diff --git a/src/tests/dill/03_gaugeProcyV2_delegationTest.js b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
index 1c6c6f5cc..b77e8f33b 100644
--- a/src/tests/dill/03_gaugeProcyV2_delegationTest.js
+++ b/src/tests/dill/03_gaugeProcyV2_delegationTest.js
@@ -47,6 +47,7 @@ describe("Vote & Distribute", () => {
       initializer: "initialize",
     });
     await GaugeProxyV2.deployed();
+
     console.log("GaugeProxyV2 deployed to:", GaugeProxyV2.address);
 
     const mDILLAddr = await GaugeProxyV2.TOKEN();
@@ -55,6 +56,22 @@ describe("Vote & Distribute", () => {
     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);
 
@@ -78,7 +95,7 @@ describe("Vote & Distribute", () => {
     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(
@@ -90,7 +107,7 @@ describe("Vote & Distribute", () => {
     /** 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);
@@ -118,9 +135,9 @@ describe("Vote & Distribute", () => {
     await userSigner.sendTransaction(populatedTx);
   });
   it("delegate should not be able to vote if owner has already voted for current period", async () => {
-    await expect(
-    GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000])
-    ).to.be.revertedWith("Delegating address has already voted");
+    await expect(GaugeProxyV2.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();
@@ -139,8 +156,8 @@ describe("Vote & Distribute", () => {
 
   it("Delegate vote should fail for user as delegation period has expired", async () => {
     /** here gov will vote on behalf of user */
-    await expect(
-    GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000])
-    ).to.be.revertedWith("Delegating period expired");
-  }); 
+    await expect(GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000])).to.be.revertedWith(
+      "Delegating period expired"
+    );
+  });
 });
diff --git a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
index b61f645d9..69565069e 100644
--- a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -87,7 +87,7 @@ describe("Liquidity Staking tests", () => {
 
     console.log("-- Deploying Gaugev2 contract --");
     const gaugeV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeV2", pickleHolderSigner);
-    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, ["PICKLE"], [pickleAddr]);
+    GaugeV2 = await gaugeV2.deploy(pickleAddr, governanceAddr, pickleHolder, ["PICKLE"], [pickleAddr]);
     await GaugeV2.deployed();
     thisContractAddr = GaugeV2.address;
     console.log("GaugeV2 deployed to:", thisContractAddr);

From f093cd66a7787343e2322e5038eb2cb46c6d25a8 Mon Sep 17 00:00:00 2001
From: Aditya Rout <adi.b20612@gmail.com>
Date: Mon, 1 Aug 2022 18:17:46 +0530
Subject: [PATCH 55/55] fix: updates and fix for better coverage

---
 src/dill/gauge-middleware.sol                 |   4 +-
 src/dill/gauge-proxy-v2.sol                   |  19 +-
 .../01_gaugeProxyV2_chunkDistTest.test.js     |  97 ++++-
 ... => 02_gaugeProxyV2_periodization.test.js} |   7 +-
 ....js => 03_gaugeProcyV2_delegation.test.js} |  34 +-
 .../dill/04_gaugeProxyV2_censorship.test.js   | 298 +++++++++++++
 .../dill/05_gaugeV2_liquidityLocking.test.js  | 171 ++++++--
 .../dill/06_GaugeV2_situtational.test.js      |   7 +-
 src/tests/dill/07_virtualGaugeV2.test.js      | 395 ++++++++++++++++++
 ..._virtualGaugeV2_gaugeProxy_upgrade.test.js | 235 +++++++++++
 10 files changed, 1190 insertions(+), 77 deletions(-)
 rename src/tests/dill/{02_gaugeProxyV2_periodizationTest.js => 02_gaugeProxyV2_periodization.test.js} (96%)
 rename src/tests/dill/{03_gaugeProcyV2_delegationTest.js => 03_gaugeProcyV2_delegation.test.js} (81%)
 create mode 100644 src/tests/dill/04_gaugeProxyV2_censorship.test.js
 create mode 100644 src/tests/dill/07_virtualGaugeV2.test.js
 create mode 100644 src/tests/dill/08_virtualGaugeV2_gaugeProxy_upgrade.test.js

diff --git a/src/dill/gauge-middleware.sol b/src/dill/gauge-middleware.sol
index 5797b49b3..993373ed8 100644
--- a/src/dill/gauge-middleware.sol
+++ b/src/dill/gauge-middleware.sol
@@ -23,7 +23,7 @@ contract GaugeMiddleware is ProtocolGovernance, Initializable {
     }
 
     function changeGaugeProxy(address _newgaugeProxy) external {
-        require(msg.sender == governance, "can only be called by gaugeProxy");
+        require(msg.sender == governance, "can only be called by governance");
         gaugeProxy = _newgaugeProxy;
     }
 
@@ -68,7 +68,7 @@ contract VirtualGaugeMiddleware is ProtocolGovernance, Initializable {
     }
 
     function changeGaugeProxy(address _newgaugeProxy) external {
-        require(msg.sender == governance, "can only be called by gaugeProxy");
+        require(msg.sender == governance, "can only be called by governance");
         gaugeProxy = _newgaugeProxy;
     }
 
diff --git a/src/dill/gauge-proxy-v2.sol b/src/dill/gauge-proxy-v2.sol
index 4db3b9052..af6a7cc5f 100644
--- a/src/dill/gauge-proxy-v2.sol
+++ b/src/dill/gauge-proxy-v2.sol
@@ -411,7 +411,10 @@ contract VirtualGaugeV2 is
     }
 
     modifier onlyJarAndAuthorised() {
-        require(msg.sender == address(jar) || authorisedAddress[msg.sender]);
+        require(
+            msg.sender == address(jar) || authorisedAddress[msg.sender],
+            "Sender not an authorized jar or address."
+        );
         _;
     }
 
@@ -424,7 +427,7 @@ contract VirtualGaugeV2 is
         string[] memory _rewardSymbols,
         address[] memory _rewardTokens
     ) {
-        require(_jar == address(0), "cannot set zero address");
+        require(_jar != address(0), "cannot set zero address");
         jar = IJar(_jar);
         rewardTokens = _rewardTokens;
         rewardSymbols = _rewardSymbols;
@@ -766,6 +769,7 @@ contract VirtualGaugeV2 is
         nonReentrant
         updateReward(account, true)
         onlyJarAndAuthorised
+        returns (uint256 _rewardsForJar)
     {
         uint256 reward;
 
@@ -773,6 +777,7 @@ contract VirtualGaugeV2 is
             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);
             }
@@ -1120,7 +1125,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
 
     function setStakingDelegate(address _delegate) public {
         require(
-            stakingDelegates[msg.sender][_delegate],
+            !stakingDelegates[msg.sender][_delegate],
             "Already a staking delegate for user!"
         );
         require(_delegate != msg.sender, "Cannot delegate to self");
@@ -1229,7 +1234,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     function depositFor(uint256 amount, address account) external {
         require(
             stakingDelegates[account][msg.sender],
-            "Only registerd delegates can deposit for their deligator"
+            "Only registered delegates can deposit for their delegator"
         );
         _deposit(amount, account, 0, block.timestamp, false);
     }
@@ -1242,7 +1247,7 @@ contract GaugeV2 is ProtocolGovernance, ReentrancyGuard {
     ) external lockable(secs) {
         require(
             stakingDelegates[account][msg.sender],
-            "Only registerd delegates can stake for their deligator"
+            "Only registered delegates can stake for their delegator"
         );
         _deposit(amount, account, secs, block.timestamp, isPermanentlyLocked);
     }
@@ -1813,7 +1818,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     // Reset votes to 0
     function reset() external {
         uint256 currentId = getCurrentPeriodId();
-        require(currentId > 0, "Voting not started yet");
+        // require(currentId > 0, "Voting not started yet");
         _reset(msg.sender, currentId);
     }
 
@@ -2017,7 +2022,7 @@ contract GaugeProxyV2 is ProtocolGovernance, Initializable {
     function addVirtualGauge(address _token, address _jar) external {
         require(msg.sender == governance, "!gov");
         require(
-            address(gaugeMiddleware) != address(0),
+            address(virtualGaugeMiddleware) != address(0),
             "cannot add new gauge without initializing gaugeMiddleware"
         );
         require(gauges[_token] == address(0x0), "exists");
diff --git a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
index b11cfa8aa..3536927c5 100644
--- a/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
+++ b/src/tests/dill/01_gaugeProxyV2_chunkDistTest.test.js
@@ -9,7 +9,8 @@ const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
-let GaugeProxyV2, userSigner, populatedTx, masterChef;
+const zeroAddr = "0x0000000000000000000000000000000000000000";
+let GaugeProxyV2, userSigner, populatedTx, masterChef, GaugeMiddleware;
 
 describe("Vote & Distribute : chunk and onlyGov distribution", () => {
   before("Setting up gaugeProxyV2", async () => {
@@ -49,7 +50,14 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
     console.log("-- Deploying GaugeProxy v2 contract --");
 
     const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
-    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
+
+    // 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();
@@ -61,37 +69,84 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
     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], {
+
+    /** 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 GaugeProxyV2.addGaugeMiddleware(GaugeMiddleware.address);
 
+    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 --");
 
-  beforeEach(async () => {
+    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()));
-  });
 
-  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,
     });
@@ -101,6 +156,28 @@ describe("Vote & Distribute : chunk and onlyGov distribution", () => {
     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",
     });
diff --git a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js b/src/tests/dill/02_gaugeProxyV2_periodization.test.js
similarity index 96%
rename from src/tests/dill/02_gaugeProxyV2_periodizationTest.js
rename to src/tests/dill/02_gaugeProxyV2_periodization.test.js
index c258529f1..871aa699a 100644
--- a/src/tests/dill/02_gaugeProxyV2_periodizationTest.js
+++ b/src/tests/dill/02_gaugeProxyV2_periodization.test.js
@@ -42,7 +42,12 @@ describe("Vote & Distribute", () => {
     /** Deploy gaugeProxyV2 */
     console.log("-- Deploying GaugeProxy v2 contract --");
     const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
-    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
+    // 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();
diff --git a/src/tests/dill/03_gaugeProcyV2_delegationTest.js b/src/tests/dill/03_gaugeProcyV2_delegation.test.js
similarity index 81%
rename from src/tests/dill/03_gaugeProcyV2_delegationTest.js
rename to src/tests/dill/03_gaugeProcyV2_delegation.test.js
index b77e8f33b..f253262da 100644
--- a/src/tests/dill/03_gaugeProcyV2_delegationTest.js
+++ b/src/tests/dill/03_gaugeProcyV2_delegation.test.js
@@ -10,7 +10,8 @@ const userAddr = "0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C";
 const pickleLP = "0xdc98556Ce24f007A5eF6dC1CE96322d65832A819";
 const pickleAddr = "0x429881672B9AE42b8EbA0E26cD9C73711b891Ca5";
 const pyveCRVETH = "0x5eff6d166d66bacbc1bf52e2c54dd391ae6b1f48";
-let GaugeProxyV2, userSigner, populatedTx, masterChef;
+const dillHolder = "0x696A27eA67Cec7D3DA9D3559Cb086db0e814FeD3";
+let GaugeProxyV2, userSigner, populatedTx, masterChef, governanceSigner;
 
 describe("Vote & Distribute", () => {
   before("Setting up gaugeProxyV2", async () => {
@@ -31,7 +32,7 @@ describe("Vote & Distribute", () => {
       params: [governanceAddr],
     });
 
-    const governanceSigner = ethers.provider.getSigner(governanceAddr);
+    governanceSigner = ethers.provider.getSigner(governanceAddr);
     userSigner = ethers.provider.getSigner(userAddr);
     masterChef = await ethers.getContractAt(
       "src/yield-farming/masterchef.sol:MasterChef",
@@ -43,7 +44,12 @@ describe("Vote & Distribute", () => {
     /** Deploy gaugeProxyV2 */
     console.log("-- Deploying GaugeProxy v2 contract --");
     const gaugeProxyV2 = await ethers.getContractFactory("/src/dill/gauge-proxy-v2.sol:GaugeProxyV2", governanceSigner);
-    GaugeProxyV2 = await upgrades.deployProxy(gaugeProxyV2, [Math.round(new Date().getTime() / 1000)], {
+    // 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();
@@ -125,7 +131,7 @@ describe("Vote & Distribute", () => {
 
   it("delegate should vote again successfully ", async () => {
     /** here gov will vote on behalf of user */
-    await GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000]);
+    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);
@@ -135,9 +141,9 @@ describe("Vote & Distribute", () => {
     await userSigner.sendTransaction(populatedTx);
   });
   it("delegate should not be able to vote if owner has already voted for current period", async () => {
-    await expect(GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [400000, 600000])).to.be.revertedWith(
-      "Delegating address has already voted"
-    );
+    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();
@@ -156,8 +162,16 @@ describe("Vote & Distribute", () => {
 
   it("Delegate vote should fail for user as delegation period has expired", async () => {
     /** here gov will vote on behalf of user */
-    await expect(GaugeProxyV2.voteFor(userAddr, [pickleLP, pyveCRVETH], [4000000, 6000000])).to.be.revertedWith(
-      "Delegating period expired"
-    );
+    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
index 69565069e..bc708d780 100644
--- a/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
+++ b/src/tests/dill/05_gaugeV2_liquidityLocking.test.js
@@ -20,7 +20,8 @@ let userSigner,
   Luffy,
   Zoro,
   Sanji,
-  Nami;
+  Nami,
+  userWithNoPickleOrDill;
 const fivePickle = ethers.utils.parseEther("5");
 
 const printStakes = async (address) => {
@@ -32,7 +33,9 @@ const printStakes = async (address) => {
       index,
       ethers.utils.formatEther(stake.liquidity),
       "ending timestamp",
-      stake.ending_timestamp
+      stake.ending_timestamp,
+      "are",
+      stake.isPermanentlyLocked ? "locked" : "unlocked"
     );
   });
   console.log("*******************************************************************************");
@@ -44,7 +47,7 @@ describe("Liquidity Staking tests", () => {
     pickleHolderSigner = ethers.provider.getSigner(pickleHolder);
     userSigner = ethers.provider.getSigner(userAddr);
     governanceSigner = ethers.provider.getSigner(governanceAddr);
-    [Luffy, Zoro, Sanji, Nami] = await ethers.getSigners();
+    [Luffy, Zoro, Sanji, Nami, userWithNoPickleOrDill] = await ethers.getSigners();
 
     console.log("-- Sending gas cost to governance addr --");
     await signer.sendTransaction({
@@ -156,13 +159,17 @@ describe("Liquidity Staking tests", () => {
     );
   });
 
-  it("notifyRewardAmount should fail when called by other than distribution ", async () => {
+  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 () => {
@@ -170,7 +177,7 @@ describe("Liquidity Staking tests", () => {
     await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
     await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
 
-    await GaugeV2.notifyRewardAmount([bal], {
+    await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal], {
       gasLimit: 9000000,
     });
     console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
@@ -246,7 +253,9 @@ describe("Liquidity Staking tests", () => {
     // 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});
+    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)))
@@ -265,7 +274,9 @@ describe("Liquidity Staking tests", () => {
     // 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});
+    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)))
@@ -296,7 +307,9 @@ describe("Liquidity Staking tests", () => {
     // 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});
+    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)))
@@ -305,7 +318,7 @@ describe("Liquidity Staking tests", () => {
     const bal = await pickle.balanceOf(thisContractAddr);
     await pickle.connect(pickleHolderSigner).approve(thisContractAddr, 0);
     await pickle.connect(pickleHolderSigner).approve(thisContractAddr, bal);
-    await GaugeV2.notifyRewardAmount([bal], {
+    await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([bal], {
       gasLimit: 9000000,
     });
     console.log("-- reward rate --", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0))));
@@ -361,32 +374,6 @@ describe("Liquidity Staking tests", () => {
     console.log("--------------------------------------------------------------------------------------");
   });
 
-  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);
-  });
-
   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"));
@@ -409,23 +396,29 @@ describe("Liquidity Staking tests", () => {
 
     await GaugeFromUser.exit({gasLimit: 9000000});
   });
-
   it("Test partial withdrawal", async () => {
     await pickle.connect(dillHolderSigner).approve(thisContractAddr, 0);
-    await pickle.connect(dillHolderSigner).approve(thisContractAddr, ethers.utils.parseEther("25"));
-    console.log(" -- deposit 5 pickle -- ");
-    await gaugeFromDillHolder.deposit(fivePickle, {gasLimit: 9000000});
+    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});
+    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});
+    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});
+    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("50"))).to.be.revertedWith(
+    await expect(gaugeFromDillHolder.partialWithdrawal(ethers.utils.parseEther("5000"))).to.be.revertedWith(
       "Withdraw amount exceeds balance"
     );
 
@@ -446,10 +439,100 @@ describe("Liquidity Staking tests", () => {
     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 -- ");
+    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
index b82f93888..d2b23a08c 100644
--- a/src/tests/dill/06_GaugeV2_situtational.test.js
+++ b/src/tests/dill/06_GaugeV2_situtational.test.js
@@ -1,4 +1,4 @@
-const {advanceNDays, advanceSevenDays} = require("./testHelper");
+const {advanceNDays} = require("./testHelper");
 const hre = require("hardhat");
 const {ethers} = require("hardhat");
 const chalk = require("chalk");
@@ -35,7 +35,7 @@ const notifyRewardAmountMethod = async (print = true, days = 7) => {
     : "";
   await pickleFromHolder.approve(thisContractAddr, 0);
   await pickleFromHolder.approve(thisContractAddr, totalSupply);
-  await GaugeV2.notifyRewardAmount([totalSupply], {
+  await GaugeV2.connect(pickleHolderSigner).notifyRewardAmount([totalSupply], {
     gasLimit: 9000000,
   });
   print ? console.log("rewardRates =>", Number(ethers.utils.formatEther(await GaugeV2.rewardRates(0)))) : "";
@@ -51,6 +51,7 @@ const getAndPrintReward = async (actor, gaugeByActor, address) => {
     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 =>`,
@@ -136,7 +137,7 @@ describe("Liquidity Staking tests", () => {
     console.log("===================================================================================================");
   });
 
-  it("Should test deposit and reward claim by multiple users", async () => {
+  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);
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());
+  });
+});