@pendle/core-v2 4.0.2 → 4.0.4

package/contracts/core/libraries/ArrayLib.sol

@@ -37,6 +37,18 @@ library ArrayLib {
         out[length] = element;
     }
 
+    function appendHead(address[] memory inp, address element) internal pure returns (address[] memory out) { 
+        uint256 length = inp.length;
+        out = new address[](length + 1);
+        out[0] = element;
+        for (uint256 i = 1; i <= length; ) {
+            out[i] = inp[i - 1];
+            unchecked {
+                i++;
+            }
+        }
+    }
+
     /**
      * @dev This function assumes a and b each contains unidentical elements
      * @param a array of addresses a

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -1,146 +1,179 @@
 pragma solidity ^0.8.0;
 
 library SDKErrorsDirectory {
-    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
-    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
-    error BulkNotMaintainer();
-    error BulkNotAdmin();
-    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
-    error BulkSellerInvalidToken(address token, address SY);
-    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
-    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
-    error ApproxFail();
-    error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
         uint256 approxGuessMin,
         uint256 approxGuessMax,
         uint256 minGuessMin,
         uint256 maxGuessMax
     );
+    error ApproxDstExecutionGasNotSet();
+    error ApproxFail();
+    error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
+    error ArrayEmpty();
+    error ArrayLengthMismatch();
+    error ArrayOutOfBounds();
+    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkNotAdmin();
+    error BulkNotMaintainer();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error CallThenRevertError(bool success, bytes res);
+    error ChainNotSupported(uint256 chainId);
+    error CooldownNotComplete();
+    error EmergencyEnabled();
+    error Expired();
+    error ExpiryInThePast(uint256 expiry);
+    error FDEpochLengthMismatch();
+    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
+    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
+    error FDInvalidPool(address pool);
+    error FDInvalidStartEpoch(uint256 startEpoch);
+    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
+    error FDPoolAlreadyExists(address pool);
+    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
+    error FailToAdd();
+    error FailToRemove();
+    error FailedToSendEther();
+    error FarmNotFound();
+    error FluxLendingError(uint256 errCode);
+    error Forbidden();
+    error GCNotPendleMarket(address caller);
+    error GCNotVotingController(address caller);
+    error InsufficientBalance();
+    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error InvalidDepositAmount();
+    error InvalidFarm();
+    error InvalidInput();
+    error InvalidMerkleProof();
+    error InvalidNft(uint256 tokenId);
+    error InvalidRange();
+    error InvalidRetryData();
+    error InvalidReward();
+    error InvalidTime();
+    error InvalidTokenId(uint256 tokenId, uint256 positionId);
+    error InvalidWTime(uint256 wTime);
+    error LiquidityNotMatch();
+    error MFNotPendleMarket(address addr);
+    error MarketExchangeRateBelowOne(int256 exchangeRate);
     error MarketExpired();
-    error MarketZeroAmountsInput();
-    error MarketZeroAmountsOutput();
-    error MarketZeroLnImpliedRate();
+    error MarketFactoryExpiredPt();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error MarketFactoryInvalidPt();
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryMarketExists();
+    error MarketFactoryOverriddenFeeTooHigh(uint80 overriddenFee, uint256 marketLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
+    error MarketFactoryZeroTreasury();
     error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
     error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
     error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
-    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
-    error MarketExchangeRateBelowOne(int256 exchangeRate);
     error MarketProportionMustNotEqualOne();
+    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
     error MarketRateScalarBelowZero(int256 rateScalar);
     error MarketScalarRootBelowZero(int256 scalarRoot);
-    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
-    error OracleUninitialized();
+    error MarketZeroAmountsInput();
+    error MarketZeroAmountsOutput();
+    error MarketZeroLnImpliedRate();
+    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
+    error MinimumRedeemAmountNotReached(uint256 amountToRedeem, uint256 minimumRedeemAmount);
+    error MinimumStakeAmountNotReached(uint256 amountToStake, uint256 minimumStakeAmount);
+    error MsgNotFromReceiveEndpoint(address sender);
+    error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+    error NotOwner();
+    error OnlyLayerZeroEndpoint();
+    error OnlyWhitelisted();
+    error OnlyYCFactory();
+    error OnlyYT();
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
     error OracleTargetTooOld(uint32 target, uint32 oldest);
+    error OracleUninitialized();
     error OracleZeroCardinality();
-    error MarketFactoryExpiredPt();
-    error MarketFactoryInvalidPt();
-    error MarketFactoryMarketExists();
-    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
-    error MarketFactoryZeroTreasury();
-    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
-    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
-    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
-    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
-    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
-    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
-    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error PhaseSettled();
+    error PoolIdDoesNotExit();
+    error PositionNotEligible();
+    error RangeNotFound();
+    error RangeNotMatch();
+    error RouterCallbackNotPendleMarket(address caller);
     error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
     error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
-    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
+    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
+    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
-    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
-    error RouterTimeRangeZero();
-    error RouterCallbackNotPendleMarket(address caller);
+    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
+    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
     error RouterInvalidAction(bytes4 selector);
     error RouterInvalidFacet(address facet);
     error RouterKyberSwapDataZero();
-    error YCExpired();
-    error YCNotExpired();
-    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
-    error YCNothingToRedeem();
-    error YCPostExpiryDataNotSet();
-    error YCNoFloatingSy();
-    error YCFactoryInvalidExpiry();
-    error YCFactoryYieldContractExisted();
-    error YCFactoryZeroExpiryDivisor();
-    error YCFactoryZeroTreasury();
-    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
-    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
-    error SYInvalidTokenIn(address token);
-    error SYInvalidTokenOut(address token);
-    error SYZeroDeposit();
-    error SYZeroRedeem();
+    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
+    error RouterTimeRangeZero();
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+    error SYBalancerInvalidPid();
+    error SYBalancerReentrancy();
+    error SYCurve3crvPoolNotFound();
+    error SYCurveInvalidPid();
     error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
     error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error SYInvalidRewardToken(address token);
+    error SYInvalidTokenIn(address token);
+    error SYInvalidTokenOut(address token);
+    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
     error SYQiTokenMintFailed(uint256 errCode);
     error SYQiTokenRedeemFailed(uint256 errCode);
     error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
-    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
-    error SYCurveInvalidPid();
-    error SYCurve3crvPoolNotFound();
-    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
-    error SYBalancerInvalidPid();
-    error SYInvalidRewardToken(address token);
     error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
-    error SYBalancerReentrancy();
-    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+    error SYZeroDeposit();
+    error SYZeroRedeem();
+    error SimulationResults(bool success, bytes res);
+    error StaderMaxDepositExceed(uint256 amountToDeposit, uint256 maxDeposit);
+    error StaderMinDepositUnreached(uint256 amountToDeposit, uint256 minDeposit);
+    error StakeNotFound();
+    error TransferFailed();
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+    error UnstakeCapacityTooLow(uint256 amountBondToRedeem, uint256 unstakeCapacity);
+    error UnsupportedOperation();
+    error UnsupportedOperationInSafeMode();
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+    error VCEpochNotFinalized(uint256 wTime);
+    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);
-    error VCZeroVePendle(address user);
-    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
-    error VCEpochNotFinalized(uint256 wTime);
     error VCPoolAlreadyAddAndRemoved(address pool);
-    error VEInvalidNewExpiry(uint256 newExpiry);
+    error VCZeroVePendle(address user);
     error VEExceededMaxLockTime();
     error VEInsufficientLockTime();
+    error VEInvalidNewExpiry(uint256 newExpiry);
     error VENotAllowedReduceExpiry();
-    error VEZeroAmountLocked();
     error VEPositionNotExpired();
+    error VEReceiveOldSupply(uint256 msgTime);
+    error VEZeroAmountLocked();
     error VEZeroPosition();
     error VEZeroSlope(uint128 bias, uint128 slope);
-    error VEReceiveOldSupply(uint256 msgTime);
-    error GCNotPendleMarket(address caller);
-    error GCNotVotingController(address caller);
-    error InvalidWTime(uint256 wTime);
-    error ExpiryInThePast(uint256 expiry);
-    error ChainNotSupported(uint256 chainId);
-    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
-    error FDEpochLengthMismatch();
-    error FDInvalidPool(address pool);
-    error FDPoolAlreadyExists(address pool);
-    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
-    error FDInvalidStartEpoch(uint256 startEpoch);
-    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
-    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
-    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
-    error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
-    error MsgNotFromReceiveEndpoint(address sender);
-    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
-    error ApproxDstExecutionGasNotSet();
-    error InvalidRetryData();
-    error ArrayLengthMismatch();
-    error ArrayEmpty();
-    error ArrayOutOfBounds();
+    error YCExpired();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryInvalidExpiry();
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
+    error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCNoFloatingSy();
+    error YCNotExpired();
+    error YCNothingToRedeem();
+    error YCPostExpiryDataNotSet();
+    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
     error ZeroAddress();
-    error FailedToSendEther();
-    error InvalidMerkleProof();
-    error OnlyLayerZeroEndpoint();
-    error OnlyYT();
-    error OnlyYCFactory();
-    error OnlyWhitelisted();
-    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
-    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
-    error MinimumStakeAmountNotReached(uint256 amountToStake, uint256 minimumStakeAmount);
-    error MinimumRedeemAmountNotReached(uint256 amountToRedeem, uint256 minimumRedeemAmount);
-    error UnstakeCapacityTooLow(uint256 amountBondToRedeem, uint256 unstakeCapacity);
-    error InvalidTokenId(uint256 tokenId, uint256 positionId);
-    error InvalidBlockRate(uint256 blockCycleNumerator);
-    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
-    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
 }

package/deployments/1-markets/SILO-CRVUSD-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Silo crvUSD",
+    "SY": "0x60D1AfD87c5Ab1a13E27638f1e75277fEbF4908C",
+    "YT": "0xAf86Da90A5C1e1a41Be3b944b16944081087b7Aa",
+    "PT": "0x386Bf9105eF88e79fb8CA53dCC9a4E6f04BE0102",
+    "market": "0xBBd395D4820da5C89A3bCA4FA28Af97254a0FCBe",
+    "expiry": 1719446400,
+    "scalarRoot": "24961452057000000000",
+    "initAnchor": "1068298884000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/1-markets/WEETH-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY EtherFi weETH",
+    "SY": "0xAC0047886a985071476a1186bE89222659970d65",
+    "YT": "0xfb35Fd0095dD1096b1Ca49AD44d8C5812A201677",
+    "PT": "0xc69Ad9baB1dEE23F4605a82b3354F8E40d1E5966",
+    "market": "0xF32e58F92e60f4b0A37A69b95d642A471365EAe8",
+    "expiry": 1719446400,
+    "scalarRoot": "10680010244000000000",
+    "initAnchor": "1111620812000000000",
+    "lnFeeRateRoot": "299955008000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -40,7 +40,8 @@
     "size": "yarn hardhat size-contracts",
     "clean": "yarn hardhat clean",
     "fcompile": "yarn clean && yarn compile",
-    "format": "yarn prettier -w contracts/**/*"
+    "format": "yarn prettier -w contracts/**/*",
+    "prepack": "yarn compile"
   },
   "packageManager": "yarn@3.3.1",
   "dependencies": {

package/typechain-types/PendleSiloWithIncentiveSY.ts

@@ -28,6 +28,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
   functions: {
     "DOMAIN_SEPARATOR()": FunctionFragment;
     "accruedRewards(address)": FunctionFragment;
+    "additionalRewardTokens(uint256)": FunctionFragment;
     "allowance(address,address)": FunctionFragment;
     "approve(address,uint256)": FunctionFragment;
     "asset()": FunctionFragment;
@@ -37,6 +38,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     "claimRewards(address)": FunctionFragment;
     "collateralToken()": FunctionFragment;
     "decimals()": FunctionFragment;
+    "defaultRewardToken()": FunctionFragment;
     "deposit(address,address,uint256,uint256)": FunctionFragment;
     "eip712Domain()": FunctionFragment;
     "exchangeRate()": FunctionFragment;
@@ -60,7 +62,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     "rewardIndexesCurrent()": FunctionFragment;
     "rewardIndexesStored()": FunctionFragment;
     "rewardState(address)": FunctionFragment;
-    "rewardToken()": FunctionFragment;
+    "setIncentiveController(address)": FunctionFragment;
     "silo()": FunctionFragment;
     "siloLens()": FunctionFragment;
     "symbol()": FunctionFragment;
@@ -81,6 +83,10 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     functionFragment: "accruedRewards",
     values: [string]
   ): string;
+  encodeFunctionData(
+    functionFragment: "additionalRewardTokens",
+    values: [BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "allowance",
     values: [string, string]
@@ -105,6 +111,10 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "defaultRewardToken",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "deposit",
     values: [string, string, BigNumberish, BigNumberish]
@@ -188,8 +198,8 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
   ): string;
   encodeFunctionData(functionFragment: "rewardState", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "rewardToken",
-    values?: undefined
+    functionFragment: "setIncentiveController",
+    values: [string]
   ): string;
   encodeFunctionData(functionFragment: "silo", values?: undefined): string;
   encodeFunctionData(functionFragment: "siloLens", values?: undefined): string;
@@ -228,6 +238,10 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     functionFragment: "accruedRewards",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "additionalRewardTokens",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "asset", data: BytesLike): Result;
@@ -246,6 +260,10 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "defaultRewardToken",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "eip712Domain",
@@ -315,7 +333,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "rewardToken",
+    functionFragment: "setIncentiveController",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "silo", data: BytesLike): Result;
@@ -347,6 +365,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
     "OwnershipTransferred(address,address)": EventFragment;
     "Paused(address)": EventFragment;
     "Redeem(address,address,address,uint256,uint256)": EventFragment;
+    "SetNewIncentiveController(address)": EventFragment;
     "Transfer(address,address,uint256)": EventFragment;
     "Unpaused(address)": EventFragment;
   };
@@ -359,6 +378,7 @@ export interface PendleSiloWithIncentiveSYInterface extends utils.Interface {
   getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "Redeem"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SetNewIncentiveController"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
 }
@@ -424,6 +444,14 @@ export type RedeemEvent = TypedEvent<
 
 export type RedeemEventFilter = TypedEventFilter<RedeemEvent>;
 
+export type SetNewIncentiveControllerEvent = TypedEvent<
+  [string],
+  { newController: string }
+>;
+
+export type SetNewIncentiveControllerEventFilter =
+  TypedEventFilter<SetNewIncentiveControllerEvent>;
+
 export type TransferEvent = TypedEvent<
   [string, string, BigNumber],
   { from: string; to: string; value: BigNumber }
@@ -470,6 +498,11 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber[]] & { rewardAmounts: BigNumber[] }>;
 
+    additionalRewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
     allowance(
       owner: string,
       spender: string,
@@ -509,6 +542,8 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     decimals(overrides?: CallOverrides): Promise<[number]>;
 
+    defaultRewardToken(overrides?: CallOverrides): Promise<[string]>;
+
     deposit(
       receiver: string,
       tokenIn: string,
@@ -616,7 +651,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       [BigNumber, BigNumber] & { index: BigNumber; lastBalance: BigNumber }
     >;
 
-    rewardToken(overrides?: CallOverrides): Promise<[string]>;
+    setIncentiveController(
+      newController: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     silo(overrides?: CallOverrides): Promise<[string]>;
 
@@ -665,6 +703,11 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
   accruedRewards(user: string, overrides?: CallOverrides): Promise<BigNumber[]>;
 
+  additionalRewardTokens(
+    arg0: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   allowance(
     owner: string,
     spender: string,
@@ -704,6 +747,8 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
   decimals(overrides?: CallOverrides): Promise<number>;
 
+  defaultRewardToken(overrides?: CallOverrides): Promise<string>;
+
   deposit(
     receiver: string,
     tokenIn: string,
@@ -801,7 +846,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
     [BigNumber, BigNumber] & { index: BigNumber; lastBalance: BigNumber }
   >;
 
-  rewardToken(overrides?: CallOverrides): Promise<string>;
+  setIncentiveController(
+    newController: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   silo(overrides?: CallOverrides): Promise<string>;
 
@@ -851,6 +899,11 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber[]>;
 
+    additionalRewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     allowance(
       owner: string,
       spender: string,
@@ -885,6 +938,8 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     decimals(overrides?: CallOverrides): Promise<number>;
 
+    defaultRewardToken(overrides?: CallOverrides): Promise<string>;
+
     deposit(
       receiver: string,
       tokenIn: string,
@@ -978,7 +1033,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       [BigNumber, BigNumber] & { index: BigNumber; lastBalance: BigNumber }
     >;
 
-    rewardToken(overrides?: CallOverrides): Promise<string>;
+    setIncentiveController(
+      newController: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
 
     silo(overrides?: CallOverrides): Promise<string>;
 
@@ -1092,6 +1150,13 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       amountTokenOut?: null
     ): RedeemEventFilter;
 
+    "SetNewIncentiveController(address)"(
+      newController?: string | null
+    ): SetNewIncentiveControllerEventFilter;
+    SetNewIncentiveController(
+      newController?: string | null
+    ): SetNewIncentiveControllerEventFilter;
+
     "Transfer(address,address,uint256)"(
       from?: string | null,
       to?: string | null,
@@ -1112,6 +1177,11 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     accruedRewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;
 
+    additionalRewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     allowance(
       owner: string,
       spender: string,
@@ -1143,6 +1213,8 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     decimals(overrides?: CallOverrides): Promise<BigNumber>;
 
+    defaultRewardToken(overrides?: CallOverrides): Promise<BigNumber>;
+
     deposit(
       receiver: string,
       tokenIn: string,
@@ -1229,7 +1301,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     rewardState(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
 
-    rewardToken(overrides?: CallOverrides): Promise<BigNumber>;
+    setIncentiveController(
+      newController: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
     silo(overrides?: CallOverrides): Promise<BigNumber>;
 
@@ -1280,6 +1355,11 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    additionalRewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     allowance(
       owner: string,
       spender: string,
@@ -1314,6 +1394,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
 
     decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    defaultRewardToken(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     deposit(
       receiver: string,
       tokenIn: string,
@@ -1410,7 +1494,10 @@ export interface PendleSiloWithIncentiveSY extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    rewardToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    setIncentiveController(
+      newController: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
     silo(overrides?: CallOverrides): Promise<PopulatedTransaction>;