@pendle/core-v2 0.11.2-testnet → 0.11.3-testnet

package/contracts/core/actions/ActionMintRedeem.sol

@@ -120,5 +120,146 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         for (uint256 i = 0; i < markets.length; ++i) {
             marketRewards[i] = IPMarket(markets[i]).redeemRewards(user);
         }
+        emit RedeemDueInterestAndRewards(
+            user,
+            scys,
+            yts,
+            markets,
+            scyRewards,
+            ytInterests,
+            ytRewards,
+            marketRewards
+        );
+    }
+
+    struct RouterTokenAmounts {
+        address[] tokens;
+        uint256[] amounts;
+    }
+
+    function redeemDueInterestAndRewardsThenSwapAll(
+        address[] calldata scys,
+        RouterYtRedeemStruct calldata dataYT,
+        address[] calldata markets,
+        RouterSwapAllStruct calldata dataSwap
+    ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped) {
+        require(dataSwap.tokens.length == dataSwap.kybercalls.length, "invalid dataSwap");
+        require(dataYT.tokenRedeemScys.length == dataYT.scyAddrs.length, "invalid dataYT");
+
+        RouterTokenAmounts memory tokensOut = _newRouterTokenAmounts(dataSwap.tokens);
+        RouterTokenAmounts memory scysOut = _newRouterTokenAmounts(dataYT.scyAddrs);
+
+        // redeem SCY
+        for (uint256 i = 0; i < scys.length; ++i) {
+            ISuperComposableYield SCY = ISuperComposableYield(scys[i]);
+
+            address[] memory rewardTokens = SCY.getRewardTokens();
+            uint256[] memory rewardAmounts = SCY.claimRewards(msg.sender);
+            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
+        }
+
+        // redeem YT
+        for (uint256 i = 0; i < dataYT.yts.length; ++i) {
+            IPYieldToken YT = IPYieldToken(dataYT.yts[i]);
+
+            (uint256 interestAmount, uint256[] memory rewardAmounts) = YT
+                .redeemDueInterestAndRewards(msg.sender, true, true);
+
+            address scyAddr = YT.SCY();
+            address[] memory rewardTokens = YT.getRewardTokens();
+
+            _addTokenAmount(scysOut, scyAddr, interestAmount);
+            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
+        }
+
+        // redeem market
+        for (uint256 i = 0; i < markets.length; ++i) {
+            IPMarket market = IPMarket(markets[i]);
+
+            address[] memory rewardTokens = market.getRewardTokens();
+            uint256[] memory rewardAmounts = market.redeemRewards(msg.sender);
+            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
+        }
+
+        // guaranteed no ETH, all rewards are ERC20
+        _transferFrom(tokensOut.tokens, msg.sender, address(this), tokensOut.amounts);
+        _redeemAllScys(scysOut, dataYT.tokenRedeemScys, tokensOut);
+
+        // now swap all to outputToken
+        netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
+        amountsSwapped = tokensOut.amounts;
+
+        emit RedeemDueInterestAndRewardsThenSwapAll(
+            msg.sender,
+            scys,
+            dataYT.yts,
+            markets,
+            dataSwap.outputToken,
+            netTokenOut
+        );
+    }
+
+    function _newRouterTokenAmounts(address[] memory tokens)
+        internal
+        pure
+        returns (RouterTokenAmounts memory)
+    {
+        return RouterTokenAmounts(tokens, new uint256[](tokens.length));
+    }
+
+    /// @dev pull SCYs from users & redeem them, then add to tokensOut
+    function _redeemAllScys(
+        RouterTokenAmounts memory scys,
+        address[] calldata tokenRedeemScys,
+        RouterTokenAmounts memory tokensOut
+    ) internal {
+        for (uint256 i = 0; i < scys.tokens.length; ++i) {
+            if (scys.amounts[i] == 0) continue;
+
+            _transferFrom(scys.tokens[i], msg.sender, scys.tokens[i], scys.amounts[i]);
+            uint256 amountOut = ISuperComposableYield(scys.tokens[i]).redeemAfterTransfer(
+                address(this),
+                tokenRedeemScys[i],
+                1
+            );
+
+            _addTokenAmount(tokensOut, tokenRedeemScys[i], amountOut);
+        }
+    }
+
+    function _swapAllToOutputToken(
+        RouterTokenAmounts memory tokens,
+        RouterSwapAllStruct memory dataSwap
+    ) internal returns (uint256 netTokenOut) {
+        for (uint256 i = 0; i < tokens.tokens.length; ++i) {
+            if (tokens.amounts[i] == 0) continue;
+            _kyberswap(tokens.tokens[i], tokens.amounts[i], dataSwap.kybercalls[i]);
+        }
+        netTokenOut = _selfBalance(dataSwap.outputToken);
+        _transferOut(dataSwap.outputToken, msg.sender, netTokenOut);
+    }
+
+    function _addTokenAmount(
+        RouterTokenAmounts memory data,
+        address token,
+        uint256 amount
+    ) internal pure {
+        for (uint256 j = 0; j < data.tokens.length; j++) {
+            if (data.tokens[j] == token) {
+                data.amounts[j] += amount;
+                return;
+            }
+        }
+        revert("token not found");
+    }
+
+    function _addTokenAmounts(
+        RouterTokenAmounts memory data,
+        address[] memory tokens,
+        uint256[] memory amounts
+    ) internal pure {
+        for (uint256 i = 0; i < tokens.length; i++) {
+            _addTokenAmount(data, tokens[i], amounts[i]);
+        }
     }
 }

package/contracts/core/actions/base/ActionBaseMintRedeem.sol

@@ -68,7 +68,6 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
                 output.tokenRedeemScy,
                 1
             );
-            _safeApproveInf(output.tokenRedeemScy, SCY);
             _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
 
             netTokenOut = _selfBalance(output.tokenOut);

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -57,6 +57,26 @@ interface IPActionMintRedeem {
         uint256 netTokenOut
     );
 
+    event RedeemDueInterestAndRewards(
+        address indexed user,
+        address[] scys,
+        address[] yts,
+        address[] markets,
+        uint256[][] scyRewards,
+        uint256[] ytInterests,
+        uint256[][] ytRewards,
+        uint256[][] marketRewards
+    );
+
+    event RedeemDueInterestAndRewardsThenSwapAll(
+        address indexed user,
+        address[] scys,
+        address[] yts,
+        address[] markets,
+        address indexed tokenOut,
+        uint256 netTokenOut
+    );
+
     function mintScyFromToken(
         address receiver,
         address SCY,
@@ -112,4 +132,27 @@ interface IPActionMintRedeem {
             uint256[][] memory ytRewards,
             uint256[][] memory marketRewards
         );
+
+    struct RouterYtRedeemStruct {
+        address[] yts;
+        // key-value pair
+        address[] scyAddrs;
+        address[] tokenRedeemScys;
+        //
+    }
+
+    struct RouterSwapAllStruct {
+        // key-value pair
+        address[] tokens;
+        bytes[] kybercalls;
+        //
+        address outputToken;
+    }
+
+    function redeemDueInterestAndRewardsThenSwapAll(
+        address[] calldata scys,
+        RouterYtRedeemStruct calldata dataYT,
+        address[] calldata markets,
+        RouterSwapAllStruct calldata dataSwap
+    ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped);
 }

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/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/helpers/PYIndex.sol

@@ -66,4 +66,13 @@ library PYIndexLib {
         return sign * (SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount.abs())).Int();
     }
 
+    function assetToScyUp(PYIndex index, int256 assetAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.assetToScyUp(PYIndex.unwrap(index), assetAmount.abs())).Int();
+    }
+
 }

package/contracts/libraries/helpers/TokenHelper.sol

@@ -8,6 +8,39 @@ abstract contract TokenHelper {
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
+    function _transferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 amount
+    ) internal {
+        if (token == NATIVE) require(msg.value == amount, "eth mismatch");
+        else if (amount != 0) IERC20(token).safeTransferFrom(from, to, amount);
+    }
+
+    function _transferFrom(
+        address[] memory tokens,
+        address from,
+        address to,
+        uint256[] memory amounts
+    ) internal {
+        uint256 length = tokens.length;
+        require(length == amounts.length, "length mismatch");
+
+        for (uint256 i = 0; i < length; ) {
+            if (amounts[i] > 0) {
+                if (tokens[i] == NATIVE) {
+                    require(msg.value == amounts[i], "native mismatch");
+                } else {
+                    IERC20(tokens[i]).safeTransferFrom(from, to, amounts[i]);
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
     function _transferIn(
         address token,
         address from,
@@ -46,30 +79,6 @@ abstract contract TokenHelper {
         }
     }
 
-    function _transferOutMaxMulti(
-        address token,
-        uint256 totalAmount,
-        address[] memory tos,
-        uint256[] memory maxAmounts
-    ) internal returns (uint256 leftover) {
-        uint256 numTos = tos.length;
-        require(numTos == maxAmounts.length, "invalid length");
-
-        leftover = totalAmount;
-        for (uint256 i = 0; i < numTos; ) {
-            uint256 maxAmount = maxAmounts[i];
-            if (maxAmount > leftover) {
-                maxAmount = leftover;
-            }
-            _transferOut(token, tos[i], maxAmount);
-            unchecked {
-                leftover -= maxAmount;
-                if (leftover == 0) break;
-                i++;
-            }
-        }
-    }
-
     function _selfBalance(address token) internal view returns (uint256) {
         return (token == NATIVE) ? address(this).balance : IERC20(token).balanceOf(address(this));
     }

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