@pendle/core-v2 0.15.3-mainnet → 0.16.0-testnet

package/contracts/core/StandardizedYield/implementations/Convex/ConvexCurveLP/Pendle3CrvAndTokenSY.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendleConvexLPSY.sol";
+import "../Pendle3CrvHelper.sol";
+import "../../../../libraries/ArrayLib.sol";
+
+contract Pendle3CrvAndTokenSY is PendleConvexLPSY {
+    using ArrayLib for address[];
+
+    uint256 public immutable indexOf3Crv;
+    uint256 public immutable indexOfOther;
+    address public immutable otherToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _cvxPid,
+        address _crvLp,
+        address _crvPool
+    ) PendleConvexLPSY(_name, _symbol, _cvxPid, _crvLp, _crvPool) {
+        indexOf3Crv = ICrvPool(_crvPool).coins(0) == Pendle3CrvHelper.LP ? 0 : 1;
+        indexOfOther = 1 - indexOf3Crv;
+        otherToken = ICrvPool(_crvPool).coins(indexOfOther);
+
+        _safeApproveInf(Pendle3CrvHelper.LP, crvPool);
+        _safeApproveInf(otherToken, crvPool);
+
+        _safeApproveInf(Pendle3CrvHelper.DAI, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDC, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDT, Pendle3CrvHelper.POOL);
+    }
+
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        override
+        returns (uint256 amountLpOut)
+    {
+        uint256 preBalanceLp = _selfBalance(crvLp);
+
+        uint256[2] memory amounts;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amount3CrvLp = Pendle3CrvHelper.deposit3Crv(tokenIn, amountTokenToDeposit);
+            amounts[indexOf3Crv] = amount3CrvLp;
+        } else {
+            // one of the 2 LP
+            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        }
+
+        ICrvPool(crvPool).add_liquidity(amounts, 0);
+
+        amountLpOut = _selfBalance(crvLp) - preBalanceLp;
+    }
+
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        address tokenToRemove = (tokenOut == otherToken) ? otherToken : Pendle3CrvHelper.LP;
+
+        uint256 preBalanceToken = _selfBalance(tokenToRemove);
+
+        ICrvPool(crvPool).remove_liquidity_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenToRemove)),
+            0
+        );
+
+        uint256 amountTokenRemoved = _selfBalance(tokenToRemove) - preBalanceToken;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            amountTokenOut = Pendle3CrvHelper.redeem3Crv(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            amountTokenOut = amountTokenRemoved;
+        }
+    }
+
+    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256[2] memory amounts;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amount3CrvLp = Pendle3CrvHelper.preview3CrvDeposit(
+                tokenIn,
+                amountTokenToDeposit
+            );
+            amounts[indexOf3Crv] = amount3CrvLp;
+        } else {
+            // one of the 2 LP
+            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        }
+
+        return ICrvPool(crvPool).calc_token_amount(amounts, true);
+    }
+
+    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256 amountTokenRemoved = ICrvPool(crvPool).calc_withdraw_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenOut))
+        );
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            return Pendle3CrvHelper.preview3CrvRedeem(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            return amountTokenRemoved;
+        }
+    }
+
+    function _getIndex(address token) internal view returns (uint256) {
+        if (token == Pendle3CrvHelper.LP || Pendle3CrvHelper.is3CrvToken(token)) {
+            return indexOf3Crv;
+        } else {
+            return indexOfOther;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = otherToken;
+        res[2] = Pendle3CrvHelper.LP;
+        res[3] = Pendle3CrvHelper.DAI;
+        res[4] = Pendle3CrvHelper.USDC;
+        res[5] = Pendle3CrvHelper.USDT;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = otherToken;
+        res[2] = Pendle3CrvHelper.LP;
+        res[3] = Pendle3CrvHelper.DAI;
+        res[4] = Pendle3CrvHelper.USDC;
+        res[5] = Pendle3CrvHelper.USDT;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool res) {
+        res = (token == crvLp ||
+            token == otherToken ||
+            token == Pendle3CrvHelper.LP ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool res) {
+        res = (token == crvLp ||
+            token == otherToken ||
+            token == Pendle3CrvHelper.LP ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+}

package/contracts/core/StandardizedYield/implementations/Convex/{base → ConvexCurveLP}/PendleConvexLPSY.sol

@@ -143,10 +143,12 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         override
         returns (uint256 amountTokenOut)
     {
+        uint256 amountLpTokenToReceive = (amountSharesToRedeem * exchangeRate()) / 1e18;
+
         if (tokenOut == crvLp) {
-            amountTokenOut = amountSharesToRedeem;
+            amountTokenOut = amountLpTokenToReceive;
         } else {
-            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountSharesToRedeem);
+            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountLpTokenToReceive);
         }
     }
 

package/contracts/core/StandardizedYield/implementations/Convex/Pendle3CrvHelper.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../interfaces/Curve/ICrvPool.sol";
+import "../../../libraries/math/Math.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library Pendle3CrvHelper {
+    using Math for uint256;
+
+    address public constant LP = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
+    address public constant POOL = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address public constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
+    address public constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
+
+    function preview3CrvDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            ICrvPool(POOL).calc_token_amount(
+                _getTokenAmounts(tokenIn, amountTokenToDeposit),
+                true
+            );
+    }
+
+    function preview3CrvRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            ICrvPool(POOL).calc_withdraw_one_coin(
+                amountSharesToRedeem,
+                _get3CrvTokenIndex(tokenOut).Int128()
+            );
+    }
+
+    function deposit3Crv(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(LP).balanceOf(address(this));
+        ICrvPool(POOL).add_liquidity(_getTokenAmounts(tokenIn, amountTokenToDeposit), 0);
+        uint256 balAfter = IERC20(LP).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function redeem3Crv(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
+        ICrvPool(POOL).remove_liquidity_one_coin(
+            amountSharesToRedeem,
+            _get3CrvTokenIndex(tokenOut).Int128(),
+            0
+        );
+        uint256 balAfter = IERC20(tokenOut).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[3] memory res)
+    {
+        res[_get3CrvTokenIndex(token)] = amount;
+    }
+
+    function _get3CrvTokenIndex(address token) internal pure returns (uint256) {
+        if (token == DAI) return 0;
+        if (token == USDC) return 1;
+        if (token == USDT) return 2;
+        revert("Pendle3CrvHelper: not valid token");
+    }
+
+    function is3CrvToken(address token) internal pure returns (bool) {
+        return (token == DAI || token == USDC || token == USDT);
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -50,10 +50,9 @@ contract PendleWstEthSY is SYBase {
             } else {
                 if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
 
-                uint256 amountStEthSharesOut = IStETH(stETH).submit{ value: amountDeposited }(
-                    address(0)
-                );
-                amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
+                uint256 preBalanceStEth = _selfBalance(stETH);
+                IStETH(stETH).submit{ value: amountDeposited }(address(0));
+                amountStETH = _selfBalance(stETH) - preBalanceStEth;
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
@@ -102,21 +101,7 @@ contract PendleWstEthSY is SYBase {
     {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
         else {
-            if (tokenIn != stETH) {
-                uint256 totalShares = IStETH(stETH).getTotalShares();
-                uint256 totalPooledEth = IStETH(stETH).getTotalPooledEther();
-                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(
-                    amountTokenToDeposit
-                );
-
-                totalShares += amountStEthSharesOut;
-                totalPooledEth += amountTokenToDeposit;
-
-                uint256 stEthBalance = (amountStEthSharesOut * totalPooledEth) / totalShares;
-                amountSharesOut = (stEthBalance * totalShares) / totalPooledEth;
-            } else {
-                amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
-            }
+            amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
         }
     }
 

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -9,7 +9,7 @@ import "../libraries/Errors.sol";
 
 import "../erc20/PendleERC20Permit.sol";
 
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
 contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
     address public immutable SY;
@@ -22,7 +22,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         _;
     }
 
-    modifier onlyYieldFactory() {
+    modifier onlYieldFactory() {
         if (msg.sender != factory) revert Errors.OnlyYCFactory();
         _;
     }
@@ -39,7 +39,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         factory = msg.sender;
     }
 
-    function initialize(address _YT) external initializer onlyYieldFactory {
+    function initialize(address _YT) external initializer onlYieldFactory {
         YT = _YT;
     }
 

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -62,15 +62,11 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     uint96 public expiryDivisor;
 
     // SY => expiry => address
-    // returns address(0) if not created
     mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
-    uint256 public constant maxInterestFeeRate = 2e17; // 20%
-    uint256 public constant maxRewardFeeRate = 2e17; // 20%
-
     constructor(
         address _ytCreationCodeContractA,
         uint256 _ytCreationCodeSizeA,
@@ -100,10 +96,10 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
      * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
      * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(
-        address SY,
-        uint32 expiry
-    ) external returns (address PT, address YT) {
+    function createYieldContract(address SY, uint32 expiry)
+        external
+        returns (address PT, address YT)
+    {
         if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
             revert Errors.YCFactoryInvalidExpiry();
 
@@ -159,31 +155,21 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     }
 
     function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
-        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
-
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        if (newInterestFeeRate > maxInterestFeeRate)
-            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
-
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
-        if (newRewardFeeRate > maxRewardFeeRate)
-            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
-
-        rewardFeeRate = newRewardFeeRate;
-        emit SetRewardFeeRate(newRewardFeeRate);
+    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        rewardFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
-        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
-
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -45,9 +45,7 @@ contract PendleYieldToken is
     address public immutable factory;
     uint256 public immutable expiry;
 
-    uint256 public syReserve;
-
-    uint128 public pyIndexLastUpdatedBlock;
+    uint128 public syReserve;
     uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
@@ -63,9 +61,6 @@ contract PendleYieldToken is
         _;
     }
 
-    /**
-     * for all txs within the same block. Otherwise, the PY index is recalculated for every tx.
-     */
     constructor(
         address _SY,
         address _PT,
@@ -80,10 +75,7 @@ contract PendleYieldToken is
         factory = msg.sender;
     }
 
-    /** 
-     * @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
-     * @dev SY should be transferred directly into this contract prior to calling this function
-     */
+    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
@@ -105,7 +97,7 @@ contract PendleYieldToken is
         amountPYOut = amountPYOuts[0];
     }
 
-    /// @notice Tokenize SY into PT + YT for multiple receivers. See `mintPY()` for more details
+    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
     function mintPYMulti(
         address[] calldata receiverPTs,
         address[] calldata receiverYTs,
@@ -124,10 +116,7 @@ contract PendleYieldToken is
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
 
-    /**
-     * @notice Converts PY tokens into SY, but interests & rewards are not redeemed at the same time
-     * @dev PT/YT tokens should be transferred into this contract prior to redeeming
-     */
+    /// @dev this function converts PY tokens into sy, but interests & rewards are not redeemed at the same time
     function redeemPY(address receiver)
         external
         nonReentrant
@@ -144,10 +133,9 @@ contract PendleYieldToken is
         amountSyOut = amountSyOuts[0];
     }
 
-    /** 
-     * @notice Converts PY tokens into SY for multiple receivers. See (`redeemPY`) for more details
-     * @dev Reverts if unable to redeem the total amount in `amountPYToRedeems`
-     */
+    /// @dev this function limit how much each receiver will receive. For example, if the totalOut is 100,
+    /// and the max are 50 30 INF, the first receiver will receive 50, the second will receive 30, and the third will receive 20.
+    /// @dev intended to mostly be used by Pendle router
     function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
         nonReentrant
@@ -160,15 +148,12 @@ contract PendleYieldToken is
     }
 
     /**
-     * @notice Redeems interests and rewards for `user`
-     * @param redeemInterest will only transfer out interest for user if true
-     * @param redeemRewards will only transfer out rewards for user if true
-     * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-     * distribution should be based on the amount of SYs that their YT currently represent, plus their
-     * dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
-     * unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
-     * accruedReward STRICTLY BEFORE transferring out their interest.
-     */
+    * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
+    distribution should be based on the amount of SYs that their YT currently represent, plus their
+    dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
+    unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
+    accruedReward STRICTLY BEFORE transferring out their interest.
+    */
     function redeemDueInterestAndRewards(
         address user,
         bool redeemInterest,
@@ -197,7 +182,6 @@ contract PendleYieldToken is
         }
     }
 
-    /// @dev reverts if called before expiry
     function redeemInterestAndRewardsPostExpiryForTreasury()
         external
         nonReentrant
@@ -224,36 +208,21 @@ contract PendleYieldToken is
         _transferOut(SY, treasury, interestOut);
     }
 
-    /// @notice updates and returns the reward indexes
     function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
         return IStandardizedYield(SY).rewardIndexesCurrent();
     }
 
-    /// @dev maximizes the current rate with the previous rate to guarantee non-decreasing rate
+    /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
     function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
         currentIndex = _pyIndexCurrent();
     }
-    
-    /// @notice returns the last-updated PY index
-    function pyIndexStored() public view returns (uint256) {
-        return _pyIndexStored;
-    }
 
-    /// @dev has no effect if called pre-expiry
     function setPostExpiryData() external nonReentrant {
         if (isExpired()) {
             _setPostExpiryData();
         }
     }
 
-    /**
-     * @notice returns the current data post-expiry, if exists
-     * @dev reverts if post-expiry data not set (see `setPostExpiryData()`)
-     * @return firstPYIndex the earliest PY index post-expiry
-     * @return totalSyInterestForTreasury current amount of SY interests post-expiry for treasury
-     * @return firstRewardIndexes the earliest reward indices post-expiry, for each reward token
-     * @return userRewardOwed amount of unclaimed user rewards, for each reward token
-     */
     function getPostExpiryData()
         external
         view
@@ -304,6 +273,10 @@ contract PendleYieldToken is
         }
     }
 
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
+
     function isExpired() public view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
@@ -363,7 +336,7 @@ contract PendleYieldToken is
     }
 
     function _updateSyReserve() internal virtual {
-        syReserve = _selfBalance(SY);
+        syReserve = _selfBalance(SY).Uint128();
     }
 
     function _getFloatingSyAmount() internal view returns (uint256 amount) {
@@ -396,14 +369,8 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        uint128 index128 = Math
-            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
-            .Uint128();
-
-        currentIndex = index128;
-        _pyIndexStored = index128;
-        pyIndexLastUpdatedBlock = uint128(block.number);
-
+        currentIndex = Math.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored);
+        _pyIndexStored = currentIndex.Uint128();
         emit NewInterestIndex(currentIndex);
     }
 

package/contracts/core/erc20/PendleERC20.sol

@@ -13,7 +13,7 @@ import "@openzeppelin/contracts/utils/Context.sol";
  * - comes with built-in reentrancy protection, storage-packed with totalSupply variable
  * - delete increaseAllowance / decreaseAllowance
  * - add nonReentrancy protection to transfer / transferFrom functions
- * - allow decimals to be passed in
+ * - allow decimals to by passed in
  * - block self-transfer by default
  */
 // solhint-disable
@@ -26,7 +26,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     mapping(address => mapping(address => uint256)) private _allowances;
 
     uint248 private _totalSupply;
-    uint8 private _status; 
+    uint8 private _status;
 
     string private _name;
     string private _symbol;
@@ -54,9 +54,12 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     }
 
     /**
-     * @dev Sets the values for {name}, {symbol} and {decimals}.
+     * @dev Sets the values for {name} and {symbol}.
      *
-     * All three of these values are immutable: they can only be set once during
+     * The default value of {decimals} is 18. To select a different value for
+     * {decimals} you should overload it.
+     *
+     * All two of these values are immutable: they can only be set once during
      * construction.
      */
     constructor(

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -164,7 +164,7 @@ library BaseSplitCodeFactory {
         uint256 creationCodeSizeA,
         address creationCodeContractB,
         uint256 creationCodeSizeB
-    ) internal view returns (bytes memory) {
+    ) public view returns (bytes memory) {
         return
             _getCreationCodeWithArgs(
                 "",

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
 contract BoringOwnableUpgradeableData {
     address public owner;