@pendle/core-v2 6.4.4-swaphubtest → 6.5.0

package/build/artifacts/contracts/router/math/MarketApproxEstimateLib.sol/MarketApproxEstimateLib.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxEstimateLib",
   "sourceName": "contracts/router/math/MarketApproxEstimateLib.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203d2d507ca73cd9503f6b7e11817078b2aa8db0f2113b26254721bc2c43f1db2164736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203d2d507ca73cd9503f6b7e11817078b2aa8db0f2113b26254721bc2c43f1db2164736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212206f6b296b2ec52c885a85373f664e24fc2f7163b4df9b51687d9a3547f0e669e664736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212206f6b296b2ec52c885a85373f664e24fc2f7163b4df9b51687d9a3547f0e669e664736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtInLibOnchain.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtInLibOnchain.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122095494ae502b7bfdbba0019e6d39882df2c4a711dc38db31a73c582c9ed03d6ad64736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122095494ae502b7bfdbba0019e6d39882df2c4a711dc38db31a73c582c9ed03d6ad64736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122065566e753bf2621ae36351eb627eef6cc5c1325ee984d29afcf56a3531fe5f3164736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122065566e753bf2621ae36351eb627eef6cc5c1325ee984d29afcf56a3531fe5f3164736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122034366e44f6420139ed2487d56e204b8de1232dac3c9bb65629a865af183ceadc64736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122034366e44f6420139ed2487d56e204b8de1232dac3c9bb65629a865af183ceadc64736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d3aff15e8a7c8701f6e441d9ee6d989f801872b2fb7994af274051575fcd2d9164736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d3aff15e8a7c8701f6e441d9ee6d989f801872b2fb7994af274051575fcd2d9164736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d7661b4cb92518316d9e208015a6ec0f1911cacce9db241c035f07caed150b4e64736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d7661b4cb92518316d9e208015a6ec0f1911cacce9db241c035f07caed150b4e64736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b3a4eb8f5b8e299591ca85bc3ab2d9bf010152f1b737b1fa9b3e4ae83d6318ec64736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b3a4eb8f5b8e299591ca85bc3ab2d9bf010152f1b737b1fa9b3e4ae83d6318ec64736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122025b5216f54828120e92bb787ec9d9cd6ff4c6366ea11487fb8856fb618fae35664736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122025b5216f54828120e92bb787ec9d9cd6ff4c6366ea11487fb8856fb618fae35664736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203cff258371db5552f845750d882726bad17fbe18954df8ef221f739e12f3aa5664736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203cff258371db5552f845750d882726bad17fbe18954df8ef221f739e12f3aa5664736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/swap-aggregator/IPSwapAggregator.sol/IPSwapAggregator.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/OKXScaleHelper.sol/IOKXDexRouter.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/OKXScaleHelper.sol/OKXScaleHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/ParaswapScaleHelper.sol/IAugustusV6.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/ParaswapScaleHelper.sol/ParaswapScaleHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/IKyberScalingHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/IOdosRouterV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/PendleSwap.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/891aa864554903c94a9d30092599d822.json"
+  "buildInfo": "../../../../build-info/629fea15dac69f6245253d3f8cf83f4e.json"
 }

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerUpg.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "../../core/libraries/Errors.sol";
+import "../../core/libraries/math/PMath.sol";
+
+import "../../interfaces/IPGaugeController.sol";
+import "../../interfaces/IPMarket.sol";
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleGaugeControllerUpg is IPGaugeController, BoringOwnableUpgradeableV2, UUPSUpgradeable {
+    using SafeERC20 for IERC20;
+    using PMath for uint256;
+
+    struct MarketRewardData {
+        uint128 pendlePerSec;
+        uint128 accumulatedPendle;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    uint256 internal constant MAX_PENDLE_PER_SEC_PER_POOL = 1e17; // i.e: 60k PENDLE per week
+
+    // solhint-disable immutable-vars-naming
+    address public immutable pendle;
+
+    mapping(address => MarketRewardData) public rewardData;
+
+    mapping(uint128 => bool) private __deprecated__epochRewardReceived;
+    mapping(address => bool) private __deprecated__isValidMarket;
+
+    uint256[99] private __gap;
+
+    constructor(address _pendle) {
+        pendle = _pendle;
+        _disableInitializers();
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    /**
+     * @dev non-market caller can also call, but just receive no rewards
+     * @dev no concern on reentracy since pendle is standard ERC20
+     */
+    function redeemMarketReward() external {
+        address market = msg.sender;
+        MarketRewardData memory rwd = _getUpdatedMarketReward(market);
+
+        uint256 amount = rwd.accumulatedPendle;
+
+        if (amount != 0) {
+            IERC20(pendle).safeTransfer(market, amount);
+            emit MarketClaimReward(market, amount);
+        }
+
+        rwd.accumulatedPendle = 0;
+        rewardData[market] = rwd;
+    }
+
+    function setRewardDatas(
+        address[] calldata markets,
+        uint128[] calldata pendlePerSecs,
+        uint128[] calldata incentiveEndsAts
+    ) external onlyOwner {
+        if (markets.length != pendlePerSecs.length || markets.length != incentiveEndsAts.length) {
+            revert Errors.ArrayLengthMismatch();
+        }
+
+        for (uint256 i = 0; i < markets.length; ++i) {
+            _setRewardData(markets[i], pendlePerSecs[i], incentiveEndsAts[i]);
+        }
+    }
+
+    function withdrawPendle(uint256 amount) external onlyOwner {
+        IERC20(pendle).safeTransfer(msg.sender, amount);
+    }
+
+    function _setRewardData(address market, uint128 newPendlePerSec, uint128 newIncentiveEndsAt) internal {
+        uint256 expiry = IPMarket(market).expiry();
+        require(block.timestamp < newIncentiveEndsAt && newIncentiveEndsAt <= expiry, "invalid incentivesEnds");
+
+        assert(newPendlePerSec <= MAX_PENDLE_PER_SEC_PER_POOL);
+
+        MarketRewardData memory rwd = _getUpdatedMarketReward(market);
+
+        rewardData[market] = MarketRewardData({
+            pendlePerSec: newPendlePerSec,
+            accumulatedPendle: rwd.accumulatedPendle,
+            lastUpdated: uint128(block.timestamp),
+            incentiveEndsAt: newIncentiveEndsAt
+        });
+
+        emit UpdateMarketRewardV2(market, newPendlePerSec, newIncentiveEndsAt);
+    }
+
+    function _getUpdatedMarketReward(address market) internal view returns (MarketRewardData memory) {
+        MarketRewardData memory rwd = rewardData[market];
+        uint128 newLastUpdated = uint128(PMath.min(block.timestamp, rwd.incentiveEndsAt));
+        rwd.accumulatedPendle += rwd.pendlePerSec * (newLastUpdated - rwd.lastUpdated);
+        rwd.lastUpdated = newLastUpdated;
+        return rwd;
+    }
+
+    /// ----------------- owner logic -----------------
+
+    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
+}

package/contracts/LiquidityMining/sPendle/StakedPendle.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
+import {IPStakedPendle} from "../../interfaces/IPStakedPendle.sol";
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+contract StakedPendle is IPStakedPendle, ERC20Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    using PMath for uint256;
+
+    address public feeReceiver;
+    address public immutable PENDLE;
+
+    mapping(address user => UserCooldown) public userCooldown;
+
+    uint24 public cooldownDuration;
+    uint64 public instantUnstakeFeeRate; // base 1e18. 5e16 means instant unstake will have to pay 5% of the amount.
+
+    constructor(address pendle) {
+        PENDLE = pendle;
+        _disableInitializers();
+    }
+
+    /// @dev reminder to also call setFeeReceiver & setCooldownDurationAndFee
+    function initialize(address _owner) external initializer {
+        __ERC20_init("StakedPendle", "sPENDLE");
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function stake(uint256 amount) external {
+        require(amount > 0, "sPendle: invalid amount");
+
+        _transferIn(PENDLE, msg.sender, amount);
+        _mint(msg.sender, amount);
+
+        emit Staked(msg.sender, amount);
+    }
+
+    function cooldown(uint256 amount) external {
+        require(amount > 0, "sPendle: invalid amount");
+        require(userCooldown[msg.sender].amount == 0, "sPendle: already in cooldown");
+
+        userCooldown[msg.sender] = UserCooldown({cooldownStart: uint104(block.timestamp), amount: amount.Uint152()});
+        _burn(msg.sender, amount);
+
+        emit CooldownInitiated(msg.sender, amount, block.timestamp);
+    }
+
+    function cancelCooldown() external {
+        UserCooldown memory data = userCooldown[msg.sender];
+        require(data.amount > 0, "sPendle: no cooldown");
+
+        delete userCooldown[msg.sender];
+        _mint(msg.sender, data.amount);
+
+        emit CooldownCanceled(msg.sender, data.amount);
+    }
+
+    function finalizeCooldown() external returns (uint256 /*amount*/) {
+        UserCooldown memory data = userCooldown[msg.sender];
+        require(data.amount > 0, "sPendle: no cooldown");
+
+        uint256 cooldownEnd = data.cooldownStart + cooldownDuration;
+        require(block.timestamp >= cooldownEnd, "sPendle: redeem not ready");
+
+        delete userCooldown[msg.sender];
+        _transferOut(PENDLE, msg.sender, data.amount);
+
+        emit Unstaked(msg.sender, data.amount, 0);
+
+        return data.amount;
+    }
+
+    function instantUnstake(uint256 amount) external returns (uint256 amountAfterFee, uint256 fee) {
+        require(amount > 0, "sPendle: invalid amount");
+
+        fee = PMath.rawDivUp(amount * instantUnstakeFeeRate, PMath.ONE);
+        amountAfterFee = amount - fee;
+
+        _burn(msg.sender, amount);
+        _transferOut(PENDLE, msg.sender, amountAfterFee);
+        _transferOut(PENDLE, feeReceiver, fee);
+
+        emit Unstaked(msg.sender, amountAfterFee, fee);
+    }
+
+    // ======== Misc helper functions =======
+
+    function multicall(Call3[] calldata calls) external returns (Result[] memory res) {
+        uint256 length = calls.length;
+        res = new Result[](length);
+        for (uint256 i = 0; i < length; i++) {
+            (bool success, bytes memory result) = _delegateToSelf(calls[i].callData, calls[i].allowFailure);
+            res[i] = Result(success, result);
+        }
+    }
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    // ======== Admin functions ========
+
+    function setFeeReceiver(address newFeeReceiver) external onlyOwner {
+        require(newFeeReceiver != address(0), "sPendle: invalid fee receiver");
+
+        feeReceiver = newFeeReceiver;
+        emit FeeReceiverUpdated(newFeeReceiver);
+    }
+
+    function setCooldownDurationAndFee(uint24 newDuration, uint64 newInstantUnstakeFeeRate) external onlyOwner {
+        require(newInstantUnstakeFeeRate <= PMath.ONE, "sPendle: invalid fee factor");
+        cooldownDuration = newDuration;
+        instantUnstakeFeeRate = newInstantUnstakeFeeRate;
+        emit CooldownDurationAndFeeUpdated(newDuration, newInstantUnstakeFeeRate);
+    }
+}

package/contracts/StPendle.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.28;
+
+import {PMath} from "./core/libraries/math/PMath.sol";
+
+enum State {
+    B, // Benefitting
+    F // Forfeited
+}
+
+struct RoundData {
+    uint256 roundId;
+    uint256 totalPooled;
+    uint256 totalShares;
+
+    uint256 _pooledForfeited;
+    uint256 _sharesForfeited;
+}
+
+library RoundDataLib {
+    using PMath for uint256;
+
+    function sharesForfeited(RoundData storage self) public view returns (uint256) {
+        return self._sharesForfeited;
+    }
+
+    function sharesBenefitting(RoundData storage self) public view returns (uint256) {
+        return self.totalShares - self._sharesForfeited;
+    }
+
+    function pooledForfeited(RoundData storage self) public view returns (uint256) {
+        return self._pooledForfeited;
+    }
+
+    function pooledBenefitting(RoundData storage self) public view returns (uint256) {
+        return self.totalPooled.mulDown(self.totalShares) - self._pooledForfeited;
+    }
+}
+
+using RoundDataLib for RoundData;
+
+struct UserData {
+    State state;
+    uint256 metaShares;
+    uint256 lastVotedRound;
+    uint256 forfeitedUntilRound;
+}
+
+contract StPendle {
+    using PMath for uint256;
+
+    mapping(address user => UserData) users;
+    mapping(uint256 roundId => RoundData) rounds;
+
+    uint256 curRound;
+    uint256 processedRound;
+
+    modifier onlyAdmin() {
+        // placeholder
+        _;
+    }
+
+    function hasInteractedBefore(address user) public view returns (bool) {
+        return users[user].metaShares > 0;
+    }
+
+    function curRoundData() internal view returns (RoundData storage stf) {
+        return rounds[curRound];
+    }
+
+    function getSideData(State state) public view returns (uint256 sidedPooled, uint256 sidedShares) {
+        RoundData storage rd = curRoundData();
+        return state == State.B  //
+            ? (rd.pooledBenefitting(), rd.sharesBenefitting())
+            : (rd.pooledForfeited(), rd.sharesForfeited());
+    }
+
+    // helper to get user data with adjusted state and meta shares
+    function getUserData(address user) external view returns (UserData memory) {
+        // need to adjust user data based on curRound and processedRound
+        return users[user];
+    }
+
+    function sharesValue(uint256 numShares) public view returns (uint256) {
+        RoundData storage rd = curRoundData();
+        if (rd.totalShares == 0) {
+            return 0;
+        }
+        return (numShares * rd.totalPooled) / rd.totalShares;
+    }
+
+    function sharesOf(address user) public view returns (uint256) {
+        UserData memory data = users[user];
+        (, uint256 sidedShares) = getSideData(data.state);
+        return data.metaShares.mulDown(sidedShares);
+    }
+
+    function balanceOf(address user) external view returns (uint256) {
+        return sharesValue(sharesOf(user)); // demonstration only, need to be more precise
+    }
+
+    function distribute(uint256 amount) external onlyAdmin {
+        RoundData storage rd = curRoundData();
+        rd.totalPooled += amount;
+        rd._sharesForfeited = rd._pooledForfeited / rd.totalPooled;
+
+        ++processedRound;
+    }
+
+    function votingBegin() public onlyAdmin {
+        ++curRound;
+    }
+
+    function votingFinalize() public onlyAdmin {
+        // todo moving group logic
+    }
+
+    // just record a vote, no actual voting logic
+    function doVote() external {}
+}

package/contracts/core/Market/PendleGauge.sol

@@ -3,105 +3,34 @@ pragma solidity ^0.8.0;
 
 import "../../interfaces/IPGauge.sol";
 import "../../interfaces/IPGaugeController.sol";
-import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 import "../RewardManager/RewardManager.sol";
 
-/**
- * Invariants to maintain:
- * - before any changes to active balance, updateAndDistributeRewards() must be called
- */
 abstract contract PendleGauge is RewardManager, IPGauge {
-    using PMath for uint256;
-    using SafeERC20 for IERC20;
     using ArrayLib for address[];
 
     address private immutable SY;
-
-    uint256 internal constant TOKENLESS_PRODUCTION = 40;
-
     address internal immutable PENDLE;
-    IPVeToken internal immutable vePENDLE;
     address internal immutable gaugeController;
 
-    uint256 public totalActiveSupply;
-    mapping(address => uint256) public activeBalance;
-
-    constructor(address _SY, address _vePendle, address _gaugeController) {
+    constructor(address _SY, address _gaugeController) {
         SY = _SY;
-        vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
         PENDLE = IPGaugeController(gaugeController).pendle();
     }
 
-    /**
-     * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
-     *     rewards is updated
-     * @dev It's intended to have user's activeBalance updated when rewards is redeemed
-     */
     function _redeemRewards(address user) internal virtual returns (uint256[] memory rewardsOut) {
         _updateAndDistributeRewards(user);
-        _updateUserActiveBalance(user);
         rewardsOut = _doTransferOutRewards(user, user);
         emit RedeemRewards(user, rewardsOut);
     }
 
-    function _updateUserActiveBalance(address user) internal virtual {
-        _updateUserActiveBalanceForTwo(user, address(0));
-    }
-
-    function _updateUserActiveBalanceForTwo(address user1, address user2) internal virtual {
-        if (user1 != address(0) && user1 != address(this)) _updateUserActiveBalancePrivate(user1);
-        if (user2 != address(0) && user2 != address(this)) _updateUserActiveBalancePrivate(user2);
-    }
-
-    /**
-     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user !=
-     * address(this)
-     */
-    function _updateUserActiveBalancePrivate(address user) private {
-        assert(user != address(0) && user != address(this));
-
-        uint256 lpBalance = _stakedBalance(user);
-        uint256 veBoostedLpBalance = _calcVeBoostedLpBalance(user, lpBalance);
-
-        uint256 newActiveBalance = PMath.min(veBoostedLpBalance, lpBalance);
-
-        totalActiveSupply = totalActiveSupply - activeBalance[user] + newActiveBalance;
-        activeBalance[user] = newActiveBalance;
-
-        emit UpdateActiveBalance(user, newActiveBalance);
-    }
-
-    function _calcVeBoostedLpBalance(address user, uint256 lpBalance) internal virtual returns (uint256) {
-        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(user);
-        // Inspired by Curve's Gauge
-        uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
-        if (vePendleSupply > 0) {
-            veBoostedLpBalance += (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION))
-                / 100;
-        }
-        return veBoostedLpBalance;
-    }
-
     function _redeemExternalReward() internal virtual override {
         IStandardizedYield(SY).claimRewards(address(this));
         IPGaugeController(gaugeController).redeemMarketReward();
     }
 
-    function _stakedBalance(address user) internal view virtual returns (uint256);
-
-    function _totalStaked() internal view virtual returns (uint256);
-
-    function _rewardSharesTotal() internal view virtual override returns (uint256) {
-        return totalActiveSupply;
-    }
-
-    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
-        return activeBalance[user];
-    }
-
     function _getRewardTokens() internal view virtual override returns (address[] memory) {
         address[] memory SYRewards = IStandardizedYield(SY).getRewardTokens();
         if (SYRewards.contains(PENDLE)) return SYRewards;
@@ -111,8 +40,4 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     function _beforeTokenTransfer(address from, address to, uint256) internal virtual {
         _updateAndDistributeRewardsForTwo(from, to);
     }
-
-    function _afterTokenTransfer(address from, address to, uint256) internal virtual {
-        _updateUserActiveBalanceForTwo(from, to);
-    }
 }