@pendle/core-v2 0.10.5-testnet → 0.11.1-testnet

package/contracts/core/actions/ActionAddRemoveLiq.sol

@@ -29,7 +29,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         external
         returns (
             uint256 netLpOut,
-            uint256 scyUsed,
+            uint256 netScyUsed,
             uint256 netPtUsed
         )
     {
@@ -37,7 +37,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             .readTokens();
 
         MarketState memory state = IPMarket(market).readState();
-        (, netLpOut, scyUsed, netPtUsed) = state.addLiquidity(
+        (, netLpOut, netScyUsed, netPtUsed) = state.addLiquidity(
             YT.newIndex(),
             netScyDesired,
             netPtDesired,
@@ -47,14 +47,21 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         // early-check
         require(netLpOut >= minLpOut, "insufficient lp out");
 
-        IERC20(SCY).safeTransferFrom(msg.sender, market, scyUsed);
+        IERC20(SCY).safeTransferFrom(msg.sender, market, netScyUsed);
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
-        netLpOut = IPMarket(market).mint(receiver);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netScyUsed, netPtUsed);
 
         // fail-safe
         require(netLpOut >= minLpOut, "FS insufficient lp out");
-        emit AddLiquidityDualScyAndPt(msg.sender, market, receiver, scyUsed, netPtUsed, netLpOut);
+        emit AddLiquidityDualScyAndPt(
+            msg.sender,
+            market,
+            receiver,
+            netScyUsed,
+            netPtUsed,
+            netLpOut
+        );
     }
 
     function addLiquidityDualTokenAndPt(
@@ -77,11 +84,11 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             .readTokens();
 
         uint256 netScyDesired = SCY.previewDeposit(tokenIn, netTokenDesired);
-        uint256 scyUsed;
+        uint256 netScyUsed;
 
         {
             MarketState memory state = IPMarket(market).readState();
-            (, netLpOut, scyUsed, netPtUsed) = state.addLiquidity(
+            (, netLpOut, netScyUsed, netPtUsed) = state.addLiquidity(
                 YT.newIndex(),
                 netScyDesired,
                 netPtDesired,
@@ -95,19 +102,19 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
         // convert tokenIn to SCY to deposit
-        netTokenUsed = (netTokenDesired * scyUsed).rawDivUp(netScyDesired);
+        netTokenUsed = (netTokenDesired * netScyUsed).rawDivUp(netScyDesired);
 
         if (tokenIn == NATIVE) {
             _transferIn(tokenIn, msg.sender, netTokenDesired);
-            SCY.deposit{ value: netTokenUsed }(market, tokenIn, netTokenUsed, scyUsed);
+            SCY.deposit{ value: netTokenUsed }(market, tokenIn, netTokenUsed, netScyUsed);
             _transferOut(tokenIn, msg.sender, netTokenDesired - netTokenUsed);
         } else {
             _transferIn(tokenIn, msg.sender, netTokenUsed);
             _safeApproveInf(tokenIn, address(SCY));
-            SCY.deposit(market, tokenIn, netTokenUsed, scyUsed);
+            SCY.deposit(market, tokenIn, netTokenUsed, netScyUsed);
         }
 
-        netLpOut = IPMarket(market).mint(receiver);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netScyUsed, netPtUsed);
         // fail-safe
         require(netLpOut >= minLpOut, "FS insufficient lp out");
 
@@ -142,8 +149,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
 
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
-        IPMarket(market).swapExactPtForScy(market, netPtSwap, EMPTY_BYTES); // ignore return, receiver = market
-        netLpOut = IPMarket(market).mint(receiver);
+        (uint256 netScyReceived, ) = IPMarket(market).swapExactPtForScy(
+            market,
+            netPtSwap,
+            EMPTY_BYTES
+        ); // ignore return, receiver = market
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netScyReceived, netPtIn - netPtSwap);
 
         require(netLpOut >= minLpOut, "insufficient lp out");
 
@@ -212,7 +223,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netScyOut, uint256 netPtOut) {
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
-        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver);
+        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
 
         require(netScyOut >= minScyOut, "insufficient SCY out");
         require(netPtOut >= minPtOut, "insufficient PT out");
@@ -239,7 +250,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
 
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
-        (, netPtOut) = IPMarket(market).burn(address(SCY), receiver);
+        (, netPtOut) = IPMarket(market).burn(address(SCY), receiver, netLpToRemove);
 
         netTokenOut = SCY.redeemAfterTransfer(receiver, tokenOut, minTokenOut);
 
@@ -279,7 +290,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         // early-check
         require(ptFromBurn + ptFromSwap >= minPtOut, "insufficient lp out");
 
-        (, ptFromBurn) = IPMarket(market).burn(market, receiver);
+        (, ptFromBurn) = IPMarket(market).burn(market, receiver, netLpToRemove);
         IPMarket(market).swapScyForExactPt(receiver, ptFromSwap, EMPTY_BYTES); // ignore return
 
         // fail-safe
@@ -296,7 +307,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 minScyOut
     ) external returns (uint256 netScyOut) {
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
-        netScyOut = _removeLiquiditySingleScy(receiver, market, minScyOut);
+        netScyOut = _removeLiquiditySingleScy(receiver, market, netLpToRemove, minScyOut);
         emit RemoveLiquiditySingleScy(msg.sender, market, receiver, netLpToRemove, netScyOut);
     }
 
@@ -311,7 +322,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
         // all output SCY is directly transferred to the SCY contract
-        uint256 netScyReceived = _removeLiquiditySingleScy(address(SCY), market, 1);
+        uint256 netScyReceived = _removeLiquiditySingleScy(address(SCY), market, netLpToRemove, 1);
 
         // since all SCY is already at the SCY contract, doPull = false
         netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
@@ -343,8 +354,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtReceivedFromScy
         );
 
-        IPMarket(market).swapScyForExactPt(market, netPtReceived, EMPTY_BYTES); // ignore return, receiver = market
-        netLpOut = IPMarket(market).mint(receiver);
+        (uint256 netScySwapped, ) = IPMarket(market).swapScyForExactPt(
+            market,
+            netPtReceived,
+            EMPTY_BYTES
+        ); // ignore return, receiver = market
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netScyIn - netScySwapped, netPtReceived);
 
         require(netLpOut >= minLpOut, "insufficient lp out");
     }
@@ -352,9 +367,14 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     function _removeLiquiditySingleScy(
         address receiver,
         address market,
+        uint256 netLpToRemove,
         uint256 minScyOut
     ) internal returns (uint256 netScyOut) {
-        (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(receiver, market);
+        (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(
+            receiver,
+            market,
+            netLpToRemove
+        );
         (uint256 scyFromSwap, ) = IPMarket(market).swapExactPtForScy(
             receiver,
             ptFromBurn,

package/contracts/interfaces/IPGauge.sol

@@ -3,4 +3,6 @@ pragma solidity 0.8.15;
 
 interface IPGauge {
     function totalActiveSupply() external view returns (uint256);
+
+    function activeBalance(address user) external view returns (uint256);
 }

package/contracts/interfaces/IPGaugeController.sol

@@ -12,7 +12,7 @@ interface IPGaugeController {
 
     function pendle() external returns (address);
 
-    function claimMarketReward() external;
+    function redeemMarketReward() external;
 
     function rewardData(address pool)
         external

package/contracts/interfaces/IPMarket.sol

@@ -38,11 +38,23 @@ interface IPMarket is IERC20Metadata, IPGauge {
         uint16 observationCardinalityNextNew
     );
 
-    function mint(address receiver) external returns (uint256 netLpOut);
-
-    function burn(address receiverScy, address receiverPt)
+    function mint(
+        address receiver,
+        uint256 netScyDesired,
+        uint256 netPtDesired
+    )
         external
-        returns (uint256 netScyOut, uint256 netPtOut);
+        returns (
+            uint256 netLpOut,
+            uint256 netScyUsed,
+            uint256 netPtUsed
+        );
+
+    function burn(
+        address receiverScy,
+        address receiverPt,
+        uint256 netLpToBurn
+    ) external returns (uint256 netScyOut, uint256 netPtOut);
 
     function swapExactPtForScy(
         address receiver,

package/contracts/interfaces/IPMarketFactory.sol

@@ -21,7 +21,7 @@ interface IPMarketFactory {
         view
         returns (
             address treasury,
-            uint96 lnFeeRateRoot,
+            uint88 lnFeeRateRoot,
             uint8 reserveFeePercent
         );
 }

package/contracts/interfaces/ISJoe.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 interface ISJoe {
     function joe() external view returns (address);
@@ -23,7 +23,7 @@ interface ISJoe {
      * @return The amount of JOE user has deposited
      * @return The reward debt for the chosen token
      */
-    function getUserInfo(address _user, IERC20Upgradeable _rewardToken)
+    function getUserInfo(address _user, IERC20 _rewardToken)
         external
         view
         returns (uint256, uint256);
@@ -42,10 +42,7 @@ interface ISJoe {
      * @param _token The address of the token
      * @return `_user`'s pending reward token
      */
-    function pendingReward(address _user, IERC20Upgradeable _token)
-        external
-        view
-        returns (uint256);
+    function pendingReward(address _user, IERC20 _token) external view returns (uint256);
 
     /**
      * @notice Withdraw JOE and harvest the rewards

package/contracts/libraries/kyberswap/AggregationRouterHelper.sol

@@ -0,0 +1,308 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.15;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IMultihopRouter.sol";
+
+library AggregationRouterHelper {
+    uint256 private constant _PARTIAL_FILL = 0x01;
+    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
+    uint256 private constant _SHOULD_CLAIM = 0x04;
+    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
+    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
+    uint256 private constant _SIMPLE_SWAP = 0x20;
+
+    uint256 private constant SLIPPAGE_RANGE = 10; // over 100
+
+    enum DexType {
+        UNI,
+        STABLESWAP,
+        CURVE,
+        KYBERDMM,
+        SADDLE,
+        UNIV3PROMM,
+        BALANCERV2,
+        KYBERRFQ,
+        DODO,
+        VELODROME,
+        PLATYPUS
+    }
+
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address[] srcReceivers;
+        uint256[] srcAmounts;
+        address dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+        bytes permit;
+    }
+
+    struct SimpleSwapData {
+        address[] firstPools;
+        uint256[] firstSwapAmounts;
+        bytes[] swapDatas;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    struct SwapExecutorDescription {
+        IMultihopRouter.Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
+        external
+        pure
+        returns (bytes memory)
+    {
+        bytes4 selector = bytes4(kybercall[:4]);
+        (
+            address caller,
+            SwapDescription memory desc,
+            bytes memory executorData,
+            bytes memory clientData
+        ) = abi.decode(kybercall[4:], (address, SwapDescription, bytes, bytes));
+
+        (desc, executorData) = _getScaledInputData(desc, executorData, newAmount);
+        return abi.encodeWithSelector(selector, caller, desc, executorData, clientData);
+    }
+
+    function _getScaledInputData(
+        SwapDescription memory desc,
+        bytes memory executorData,
+        uint256 newAmount
+    ) internal pure returns (SwapDescription memory, bytes memory) {
+        uint256 flags = desc.flags;
+        uint256 oldAmount = desc.amount;
+        if (oldAmount == newAmount) {
+            return (desc, executorData);
+        }
+
+        //if the difference of newAmount and oldAmount > 5%, revert
+        require(
+            (oldAmount * (100 - SLIPPAGE_RANGE)) / 100 <= newAmount &&
+                newAmount <= (oldAmount * (100 + SLIPPAGE_RANGE)) / 100,
+            "kyber: difference too large"
+        );
+
+        // simple mode swap
+        if (flags & _SIMPLE_SWAP != 0) {
+            require(desc.srcReceivers.length == 0, "kyber: can't scale if take fee");
+            return (
+                _getNewDescription(desc, oldAmount, newAmount),
+                _getNewSimpleSwapData(executorData, oldAmount, newAmount)
+            );
+        }
+
+        //normal mode swap
+        bytes memory newExecutorData = _getNewExecutorData(executorData, oldAmount, newAmount);
+        return (_getNewDescription(desc, oldAmount, newAmount), newExecutorData);
+    }
+
+    function _getNewDescription(
+        SwapDescription memory desc,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (SwapDescription memory) {
+        uint256 oldMinReturnAmount = desc.minReturnAmount;
+        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
+        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
+        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
+        desc.amount = newAmount;
+        if (desc.srcReceivers.length == 0) {
+            return desc;
+        }
+
+        uint256 newTotal;
+        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
+            if (i == desc.srcReceivers.length - 1) {
+                desc.srcAmounts[i] = newAmount - newTotal;
+            } else {
+                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
+            }
+            newTotal += desc.srcAmounts[i];
+        }
+        return desc;
+    }
+
+    function _getNewSimpleSwapData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
+        uint256 numberSeq = swapData.firstPools.length;
+        uint256 newTotalSwapAmount;
+        for (uint256 i = 0; i < numberSeq; i++) {
+            if (i == numberSeq - 1) {
+                swapData.firstSwapAmounts[i] = newAmount - newTotalSwapAmount;
+            } else {
+                swapData.firstSwapAmounts[i] =
+                    (swapData.firstSwapAmounts[i] * newAmount) /
+                    oldAmount;
+            }
+            newTotalSwapAmount += swapData.firstSwapAmounts[i];
+        }
+        return abi.encode(swapData);
+    }
+
+    function _getNewExecutorData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SwapExecutorDescription memory swapExecutorDescription = abi.decode(
+            data,
+            (SwapExecutorDescription)
+        );
+        swapExecutorDescription.minTotalAmountOut =
+            (swapExecutorDescription.minTotalAmountOut * newAmount) /
+            oldAmount;
+
+        uint256 newTotalSwapAmount;
+        for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
+            IMultihopRouter.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
+            uint8 dexType = uint8(swap.dexOption >> 8);
+            uint256 value;
+            if (i == swapExecutorDescription.swapSequences.length - 1)
+                value = newAmount - newTotalSwapAmount;
+
+            if (dexType == uint8(DexType.UNI)) {
+                (swap.data, value) = _newUniSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.STABLESWAP) || dexType == uint8(DexType.SADDLE)) {
+                (swap.data, value) = _newStableSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.CURVE)) {
+                (swap.data, value) = _newCurveSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.KYBERDMM)) {
+                (swap.data, value) = _newKyberDMMSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.UNIV3PROMM)) {
+                (swap.data, value) = _newUniV3ProMMSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.BALANCERV2)) {
+                (swap.data, value) = _newBalancerV2Swap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.KYBERRFQ)) {
+                revert("kyber: can't scale kyberrfq");
+            } else if (dexType == uint8(DexType.DODO)) {
+                (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.VELODROME)) {
+                (swap.data, value) = _newVelodromeSwap(swap.data, value, oldAmount, newAmount);
+            } else {
+                revert("AggregationExecutor: Dex type not supported");
+            }
+            newTotalSwapAmount += value;
+        }
+        return abi.encode(swapExecutorDescription);
+    }
+
+    function _newUniSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.UniSwap memory uniSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        if (value > 0) uniSwap.collectAmount = value;
+        else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
+        return (abi.encode(uniSwap), uniSwap.collectAmount);
+    }
+
+    function _newStableSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.StableSwap memory stableSwap = abi.decode(
+            data,
+            (IMultihopRouter.StableSwap)
+        );
+        if (value > 0) stableSwap.dx = value;
+        else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
+        return (abi.encode(stableSwap), stableSwap.dx);
+    }
+
+    function _newCurveSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.CurveSwap memory curveSwap = abi.decode(data, (IMultihopRouter.CurveSwap));
+        if (value > 0) curveSwap.dx = value;
+        else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
+        return (abi.encode(curveSwap), curveSwap.dx);
+    }
+
+    function _newKyberDMMSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.UniSwap memory kyberDMMSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        if (value > 0) kyberDMMSwap.collectAmount = value;
+        else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
+        return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
+    }
+
+    function _newUniV3ProMMSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+            data,
+            (IMultihopRouter.UniSwapV3ProMM)
+        );
+        if (value > 0) uniSwapV3ProMM.swapAmount = value;
+        else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
+        return (abi.encode(uniSwapV3ProMM), uniSwapV3ProMM.swapAmount);
+    }
+
+    function _newBalancerV2Swap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.BalancerV2 memory balancerV2 = abi.decode(
+            data,
+            (IMultihopRouter.BalancerV2)
+        );
+        if (value > 0) balancerV2.amount = value;
+        else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
+        return (abi.encode(balancerV2, balancerV2.amount), balancerV2.amount);
+    }
+
+    function _newDODOSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.DODO memory dodo = abi.decode(data, (IMultihopRouter.DODO));
+        if (value > 0) dodo.amount = value;
+        else dodo.amount = (dodo.amount * newAmount) / oldAmount;
+        return (abi.encode(dodo), dodo.amount);
+    }
+
+    function _newVelodromeSwap(
+        bytes memory data,
+        uint256 value,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory, uint256) {
+        IMultihopRouter.UniSwap memory velodrome = abi.decode(data, (IMultihopRouter.UniSwap));
+        if (value > 0) velodrome.collectAmount = value;
+        else velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
+        return (abi.encode(velodrome), velodrome.collectAmount);
+    }
+}