@pendle/core-v2 0.8.1-beta → 0.8.1-gamma

package/contracts/SuperComposableYield/SCY-implementations/TraderJoe/PendleSJoeSCY.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../base-implementations/SCYBaseWithRewards.sol";
+import "../../../interfaces/ISJoe.sol";
+
+/*
+sJOE Staking
+sJOE Staking is a highly accessible Staking option. Users can Stake into sJOE and unstake from sJOE at any time. There is however a deposit fee mechanism to prevent over-saturation.
+
+Deposit Fee
+Staking into sJOE may come with a fee
+The fee can scale up to 3% Max, depending on the number of JOEs already Staked
+The 3% Fee is taken from the JOEs that you deposit into the sJOE Pool
+Currently any deposit fee taken will be sent to the Treasury
+
+
+Yield Generating Mechanism - Stake JOE into SJOE Contract
+
+Asset - JOE
+
+Shares - Shares (in contract *take note of deduction of fees after depositing)
+
+Exchange Rate - Increases with sJOE rewards
+
+
+*/
+// sJOE -> Staking contract that accepts JOE and yields USDC as the ONLY reward token
+// sJOE Contract Address on Avalanche -> 0x1a731B2299E22FbAC282E7094EdA41046343Cb51
+
+// JOE Contract Address on Avalanche -> 0x6e84a6216ea6dacc71ee8e6b0a5b7322eebc0fdd
+
+contract PendleSJoeSCY is SCYBaseWithRewards {
+    using SafeERC20 for IERC20;
+
+    address public immutable SJOE;
+    address public immutable JOE;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sJOE
+    ) SCYBaseWithRewards(_name, _symbol, _sJOE) {
+        require(_sJOE != address(0), "zero address");
+        SJOE = _sJOE;
+        JOE = ISJoe(SJOE).joe();
+
+        _safeApprove(JOE, SJOE, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is JOE (Since the amount of rewards is based on how much staked JOE inside sJOE contract). Only the base token JOE should be accepted. Then the corresponding amount of shares is returned.
+     *
+     * The exchange rate of JOE to shares is 1:1
+
+    * Each time deposit() is called, any pending rewards will be sent back to the SCY by default.
+     */
+    function _deposit(address, uint256 amount)
+        internal
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 preBalanceSJoe = ISJoe(SJOE).internalJoeBalance();
+
+        ISJoe(SJOE).deposit(amount);
+
+        // Depositing JOE will incur deposit fee, hence amountSharesOut has to be calculated like this for accurate amount of SCY exchanged.
+        amountSharesOut = ISJoe(SJOE).internalJoeBalance() - preBalanceSJoe;
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of JOE Tokens. Hence `tokenOut` will only be the underlying asset (JOE) in this case. Since there will NOT be any withdrawal fee from sJOE, amountSharesToRedeem will always correspond amountTokenOut.
+     */
+    function _redeem(address, uint256 amountSharesToRedeem)
+        internal
+        override
+        returns (uint256 amountTokenOut)
+    {
+        ISJoe(SJOE).withdraw(amountSharesToRedeem);
+        amountTokenOut = amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Exchange rate for JOE to SCY is 1:1
+     * @dev It is the exchange rate of Shares in sJOE to its underlying asset (JOE)
+     */
+    function exchangeRate() public pure override returns (uint256) {
+        return SCYUtils.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        ISJoe SJOEContract = ISJoe(SJOE);
+
+        uint256 length = SJOEContract.rewardTokensLength();
+
+        res = new address[](length);
+        for (uint256 i = 0; i < length; ) {
+            res[i] = SJOEContract.rewardTokens(i);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function _redeemExternalReward() internal override {
+        // Since sJOE contract has no 'claimRewards' function, call withdraw() with a 0 amount to claim the rewards - Same as how sJOE pool is doing for their frontend.
+        ISJoe(SJOE).withdraw(0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 sJoeDepositFeePrecision = ISJoe(SJOE).depositFeePercent();
+
+        amountSharesOut =
+            (((1e18 - sJoeDepositFeePrecision / 1e18) * amountTokenToDeposit) * 1e18) /
+            exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        pure
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = JOE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = JOE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == JOE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == JOE;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, JOE, IERC20Metadata(JOE).decimals());
+    }
+}

package/contracts/core/LiquidityMining/CelerAbstracts/CelerSenderUpg.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.15;
 
 import "../../../interfaces/ICelerMessageBus.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
@@ -15,10 +16,18 @@ abstract contract CelerSenderUpg is PermissionsV2Upg {
 
     ICelerMessageBus public celerMessageBus;
 
-    EnumerableMap.UintToAddressMap internal sidechainContracts;
+    // destinationContracts mapping contains one address for each chainId only
+    EnumerableMap.UintToAddressMap internal destinationContracts;
 
     uint256[100] private __gap;
 
+    modifier refundUnusedEth() {
+        _;
+        if (address(this).balance > 0) {
+            Address.sendValue(payable(msg.sender), address(this).balance);
+        }
+    }
+
     constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
 
     function setCelerMessageBus(address _celerMessageBus) external onlyGovernance {
@@ -26,35 +35,35 @@ abstract contract CelerSenderUpg is PermissionsV2Upg {
     }
 
     function _sendMessage(uint256 chainId, bytes memory message) internal {
-        assert(sidechainContracts.contains(chainId));
-        address toAddr = sidechainContracts.get(chainId);
+        assert(destinationContracts.contains(chainId));
+        address toAddr = destinationContracts.get(chainId);
         uint256 fee = celerMessageBus.calcFee(message);
         require(msg.value >= fee, "Insufficient celer fee");
         celerMessageBus.sendMessage{ value: fee }(toAddr, chainId, message);
     }
 
-    function _afterAddSidechainContract(address addr, uint256 chainId) internal virtual {}
+    function _afterAddDestinationContract(address addr, uint256 chainId) internal virtual {}
 
-    function addSidechainContract(address _address, uint256 _chainId)
+    function addDestinationContract(address _address, uint256 _chainId)
         external
         payable
         onlyGovernance
     {
-        sidechainContracts.set(_chainId, _address);
-        _afterAddSidechainContract(_address, _chainId);
+        destinationContracts.set(_chainId, _address);
+        _afterAddDestinationContract(_address, _chainId);
     }
 
-    function getAllSidechainContracts()
+    function getAllDestinationContracts()
         public
         view
         returns (uint256[] memory chainIds, address[] memory addrs)
     {
-        uint256 length = sidechainContracts.length();
+        uint256 length = destinationContracts.length();
         chainIds = new uint256[](length);
         addrs = new address[](length);
 
         for (uint256 i = 0; i < length; ++i) {
-            (chainIds[i], addrs[i]) = sidechainContracts.at(i);
+            (chainIds[i], addrs[i]) = destinationContracts.at(i);
         }
     }
 }

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -7,6 +7,7 @@ import "../../../libraries/math/Math.sol";
 import "../../../libraries/math/WeekMath.sol";
 import "../../../interfaces/IPGaugeController.sol";
 import "../../../interfaces/IPMarketFactory.sol";
+import "../../../interfaces/IPMarket.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -101,7 +102,8 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, Permissions
         epochRewardReceived[wTime] = true;
 
         for (uint256 i = 0; i < markets.length; ++i) {
-            _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
+            if (!IPMarket(markets[i]).isExpired())
+                _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
         }
 
         emit ReceiveVotingResults(wTime, markets, pendleAmounts);

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -80,8 +80,9 @@ abstract contract PendleGauge is RewardManager {
         virtual
         returns (uint256)
     {
-        uint256 vePendleBalance = vePENDLE.balanceOf(user);
-        uint256 vePendleSupply = vePENDLE.totalSupplyCurrent();
+        (uint256 vePendleBalance, uint256 vePendleSupply) = vePENDLE.totalSupplyAndBlanaceCurrent(
+            user
+        );
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {

package/contracts/core/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -79,15 +79,22 @@ contract PendleVotingControllerUpg is
             if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
         }
 
+        // Process weight-decrease pools first
         for (uint256 i = 0; i < pools.length; ++i) {
-            if (uData.voteForPools[pools[i]].weight <= weights[i])
+            if (uData.voteForPools[pools[i]].weight > weights[i])
                 _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
         }
 
+        // Process weight-increase pools
         for (uint256 i = 0; i < pools.length; ++i) {
-            if (uData.voteForPools[pools[i]].weight > weights[i])
+            if (uData.voteForPools[pools[i]].weight <= weights[i])
                 _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
         }
+
+        require(
+            uData.totalVotedWeight <= VeBalanceLib.USER_VOTE_MAX_WEIGHT,
+            "exceeded max weight"
+        );
     }
 
     /**
@@ -141,7 +148,7 @@ contract PendleVotingControllerUpg is
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
-    function broadcastResults(uint64 chainId) external payable {
+    function broadcastResults(uint64 chainId) external payable refundUnusedEth {
         uint128 wTime = WeekMath.getCurrentWeekStart();
         require(weekData[wTime].isEpochFinalized, "epoch not finalized");
         _broadcastResults(chainId, wTime, pendlePerSec);
@@ -202,7 +209,7 @@ contract PendleVotingControllerUpg is
         uint64 chainId,
         uint128 wTime,
         uint128 forcedPendlePerSec
-    ) external payable onlyGovernance {
+    ) external payable onlyGovernance refundUnusedEth {
         _broadcastResults(chainId, wTime, forcedPendlePerSec);
     }
 
@@ -218,6 +225,18 @@ contract PendleVotingControllerUpg is
         emit SetPendlePerSec(newPendlePerSec);
     }
 
+    function getBroadcastResultFee(uint64 chainId) external view returns (uint256) {
+        if (chainId == block.chainid) return 0; // Mainchain broadcast
+
+        uint256 length = chainPools[chainId].length();
+        if (length == 0) return 0;
+
+        address[] memory pools = new address[](length);
+        uint256[] memory totalPendleAmounts = new uint256[](length);
+
+        return celerMessageBus.calcFee(abi.encode(uint128(0), pools, totalPendleAmounts));
+    }
+
     /*///////////////////////////////////////////////////////////////
                     INTERNAL FUNCTIONS
     //////////////////////////////////////////////////////////////*/
@@ -244,12 +263,11 @@ contract PendleVotingControllerUpg is
 
         for (uint256 i = 0; i < length; ++i) {
             uint256 poolVotes = weekData[wTime].poolVotes[pools[i]];
-            uint256 pendlePerSec = (totalPendlePerSec * poolVotes) / totalVotes;
-            totalPendleAmounts[i] = pendlePerSec * WEEK;
+            totalPendleAmounts[i] = (totalPendlePerSec * poolVotes * WEEK) / totalVotes;
         }
 
         if (chainId == block.chainid) {
-            address gaugeController = sidechainContracts.get(chainId);
+            address gaugeController = destinationContracts.get(chainId);
             IPGaugeControllerMainchain(gaugeController).updateVotingResults(
                 wTime,
                 pools,

package/contracts/core/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -210,10 +210,6 @@ abstract contract VotingControllerStorageUpg {
 
             uData.voteForPools[pool] = UserPoolData(weight, newVote);
             uData.totalVotedWeight += weight;
-            require(
-                uData.totalVotedWeight <= VeBalanceLib.USER_VOTE_MAX_WEIGHT,
-                "exceeded max weight"
-            );
         }
 
         userPoolHistory[user][pool].push(newVote);

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -16,6 +16,10 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     bytes private constant EMPTY_BYTES = abi.encode();
+    bytes private constant SAMPLE_SUPPLY_UPDATE_MESSAGE =
+        abi.encode(0, VeBalance(0, 0), EMPTY_BYTES);
+    bytes private constant SAMPLE_POSITION_UPDATE_MESSAGE =
+        abi.encode(0, VeBalance(0, 0), abi.encode(address(0), LockedPosition(0, 0)));
 
     IERC20 public immutable pendle;
 
@@ -41,7 +45,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         uint128 additionalAmountToLock,
         uint128 newExpiry,
         uint256[] calldata chainIds
-    ) external payable returns (uint128 newVeBalance) {
+    ) external payable refundUnusedEth returns (uint128 newVeBalance) {
         newVeBalance = increaseLockPosition(additionalAmountToLock, newExpiry);
         broadcastUserPosition(msg.sender, chainIds);
     }
@@ -67,6 +71,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         );
 
         require(newExpiry <= block.timestamp + MAX_LOCK_TIME, "max lock time exceeded");
+        require(positionData[user].expiry <= newExpiry, "new expiry must be after current expiry");
 
         uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
         require(newTotalAmountLocked > 0, "zero total amount locked");
@@ -111,7 +116,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - _totalSupply & lastSlopeChangeAppliedAt is updated
      */
-    function totalSupplyCurrent() external virtual override returns (uint128) {
+    function totalSupplyCurrent() public virtual override returns (uint128) {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
@@ -121,7 +126,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - all chains in chainIds receive the new totalSupply
      */
-    function broadcastTotalSupply(uint256[] calldata chainIds) public payable {
+    function broadcastTotalSupply(uint256[] calldata chainIds) public payable refundUnusedEth {
         _broadcastPosition(address(0), chainIds);
     }
 
@@ -130,7 +135,11 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - all chains in chainIds receive the new totalSupply & user's new position
      */
-    function broadcastUserPosition(address user, uint256[] calldata chainIds) public payable {
+    function broadcastUserPosition(address user, uint256[] calldata chainIds)
+        public
+        payable
+        refundUnusedEth
+    {
         require(user != address(0), "zero address user");
         _broadcastPosition(user, chainIds);
     }
@@ -140,6 +149,14 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         return userHistory[user].getAtTimestamp(timestamp);
     }
 
+    function getBroadcastSupplyFee(uint256[] calldata chainIds) external view returns (uint256) {
+        return celerMessageBus.calcFee(SAMPLE_SUPPLY_UPDATE_MESSAGE) * chainIds.length;
+    }
+
+    function getBroadcastPositionFee(uint256[] calldata chainIds) external view returns (uint256) {
+        return celerMessageBus.calcFee(SAMPLE_POSITION_UPDATE_MESSAGE) * chainIds.length;
+    }
+
     /**
      * @notice increase the locking position of the user
      * @dev it works by simply removing the old position from all relevant data (as if the user has never locked) and
@@ -206,38 +223,38 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         _totalSupply = supply;
         lastSlopeChangeAppliedAt = wTime;
 
-        return (supply, lastSlopeChangeAppliedAt);
+        return (supply, wTime);
     }
 
     /// @notice broadcast position to all chains in chainIds
     function _broadcastPosition(address user, uint256[] calldata chainIds) public payable {
         require(chainIds.length != 0, "empty chainIds");
 
-        (VeBalance memory supply, uint256 wTime) = _applySlopeChange();
+        (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
 
         bytes memory userData = (
             user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
         );
 
         for (uint256 i = 0; i < chainIds.length; ++i) {
-            require(sidechainContracts.contains(chainIds[i]), "not supported chain");
+            require(destinationContracts.contains(chainIds[i]), "not supported chain");
             _broadcast(chainIds[i], wTime, supply, userData);
-            if (user != address(0)) {
-                emit BroadcastUserPosition(user, chainIds);
-            }
         }
 
+        if (user != address(0)) {
+            emit BroadcastUserPosition(user, chainIds);
+        }
         emit BroadcastTotalSupply(supply, chainIds);
     }
 
-    function _afterAddSidechainContract(address, uint256 chainId) internal virtual override {
-        (VeBalance memory supply, uint256 wTime) = _applySlopeChange();
+    function _afterAddDestinationContract(address, uint256 chainId) internal virtual override {
+        (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
         _broadcast(chainId, wTime, supply, EMPTY_BYTES);
     }
 
     function _broadcast(
         uint256 chainId,
-        uint256 wTime,
+        uint128 wTime,
         VeBalance memory supply,
         bytes memory userData
     ) internal {

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -19,7 +19,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     constructor(address _governanceManager) CelerReceiverUpg(_governanceManager) {}
 
-    function totalSupplyCurrent() external view virtual override returns (uint128) {
+    function totalSupplyCurrent() public view virtual override returns (uint128) {
         return totalSupplyStored();
     }
 
@@ -65,9 +65,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     function balanceOf(address user) public view virtual override returns (uint128) {
         address delegator = delegatorOf[user];
-        if (delegatorOf[user] == address(0)) {
-            return super.balanceOf(user);
-        }
+        if (delegator == address(0)) return super.balanceOf(user);
         return super.balanceOf(delegator);
     }
 }

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowTokenBase.sol

@@ -43,9 +43,13 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
         return _totalSupply.getCurrentValue();
     }
 
-    function totalSupplyCurrent() external virtual returns (uint128);
+    function totalSupplyCurrent() public virtual returns (uint128);
 
     function _isPositionExpired(address user) internal view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
     }
+
+    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128) {
+        return (balanceOf(user), totalSupplyCurrent());
+    }
 }

package/contracts/core/Market/PendleMarket.sol

@@ -13,7 +13,6 @@ import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
-import "../PendleERC20Permit.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 /**
@@ -27,7 +26,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using Math for int256;
     using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     struct MarketStorage {
         int128 totalPt;
@@ -90,7 +89,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         returns (uint256 lpToAccount)
     {
         MarketState memory market = readState(true);
-        SCYIndex index = SCY.newIndex();
+        PYIndex index = YT.newIndex();
 
         uint256 scyDesired = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
         uint256 ptDesired = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
@@ -161,7 +160,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         MarketState memory market = readState(true);
 
         (netScyOut, netScyToReserve) = market.swapExactPtForScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactPtIn,
             block.timestamp
         );
@@ -198,7 +197,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         MarketState memory market = readState(true);
 
         (netScyIn, netScyToReserve) = market.swapScyForExactPt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactPtOut,
             block.timestamp
         );

package/contracts/core/Market/PendleMarketFactory.sol

@@ -85,7 +85,7 @@ contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory
         // no need salt since market's existence has been checked before hand
         market = SSTORE2Deployer.create2(
             marketCreationCodePointer,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController)
         );
 

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -12,8 +12,6 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/helpers/TokenHelper.sol";
 
-import "../PendleERC20Permit.sol";
-
 /*
 With YT yielding more SCYs overtime, which is allowed to be redeemed by users, the reward distribution should
 be based on the amount of SCYs that their YT currently represent, plus with their dueInterest.

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,11 +4,11 @@ pragma solidity 0.8.15;
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../PendleERC20Permit.sol";
+import "../PendleERC20.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SCY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -30,7 +30,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SCY = _SCY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -98,7 +98,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         // no need salt since PT (and also YT) existence has been checked before hand
         PT = SSTORE2Deployer.create2(
             type(PendlePrincipalToken).creationCode,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT_PREFIX.concat(_SCY.name(), expiry, " "),
@@ -110,7 +110,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
 
         YT = SSTORE2Deployer.create2(
             pendleYtCreationCodePointer,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT,