@pendle/core-v2 4.5.1-beta-2 → 4.5.1-beta-4

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwellStakingERC20SY.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Swell/ISwellSimpleStakingERC20.sol";
+
+contract PendleSwellStakingERC20SY is SYBase {
+    using ArrayLib for address[];
+
+    address public constant SWELL_STAKING = 0x38D43a6Cb8DA0E855A42fB6b0733A0498531d774;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable stakeToken;
+
+    constructor(string memory _name, string memory _symbol, address _stakeToken) SYBase(_name, _symbol, _stakeToken) {
+        stakeToken = _stakeToken;
+        _safeApproveInf(_stakeToken, SWELL_STAKING);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn != stakeToken) {
+            amountDeposited = _wrapToStakeToken(tokenIn, amountDeposited);
+        }
+        ISwellSimpleStakingERC20(SWELL_STAKING).deposit(stakeToken, amountDeposited, address(this));
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        ISwellSimpleStakingERC20(SWELL_STAKING).withdraw(stakeToken, amountSharesToRedeem, receiver);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == stakeToken) {
+            return amountTokenToDeposit;
+        }
+        return _previewToStakeToken(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(stakeToken).merge(_getAdditionalTokens());
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(stakeToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stakeToken || _canWrapToStakeToken(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stakeToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, stakeToken, IERC20Metadata(stakeToken).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ADDITIONAL TOKEN IN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getAdditionalTokens() internal view virtual returns (address[] memory) {}
+
+    function _previewToStakeToken(address, uint256) internal view virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _wrapToStakeToken(address, uint256) internal virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _canWrapToStakeToken(address) internal view virtual returns (bool) {
+        return false;
+    }
+}

package/contracts/interfaces/IPActionMiscV3.sol

@@ -105,7 +105,7 @@ interface IPActionMiscV3 {
         address indexed market,
         address indexed token,
         address receiver,
-        uint256 netLpToRemove,
+        uint256 netLpIn,
         uint256 totalTokenOut,
         ExitPreExpReturnParams params
     );
@@ -114,7 +114,7 @@ interface IPActionMiscV3 {
         address indexed caller,
         address indexed market,
         address indexed receiver,
-        uint256 netLpToRemove,
+        uint256 netLpIn,
         ExitPreExpReturnParams params
     );
 
@@ -235,6 +235,13 @@ interface IPActionMiscV3 {
         uint256 minSyOut
     ) external returns (ExitPostExpReturnParams memory params);
 
+    function callAndReflect(
+        address payable reflector,
+        bytes calldata selfCall1,
+        bytes calldata selfCall2,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes);
+
     function boostMarkets(address[] memory markets) external;
 
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory res);

package/contracts/interfaces/IPGovernanceProxy.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPGovernanceProxy {
+    struct Call {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function pause(address[] calldata addrs) external;
+
+    function aggregate(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
+}

package/contracts/interfaces/IPPausingInterface.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPausingInterface {
+    function pause() external;
+
+    function unpause() external;
+}

package/contracts/interfaces/IPReflector.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPReflector {
+    function reflect(bytes calldata inputData) external returns (bytes memory result);
+}

package/contracts/interfaces/Swell/ISwellSimpleStakingERC20.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+interface ISwellSimpleStakingERC20 {
+    /// @notice Struct to hold the supported booleans
+    /// @param deposit true if deposit is supported
+    /// @param withdraw true if withdraw is supported
+    struct Supported {
+        bool deposit;
+        bool withdraw;
+    }
+
+    /// @notice Error emitted when the amount is null
+    error AMOUNT_NULL();
+
+    /// @notice Error emitted when the address is null
+    error ADDRESS_NULL();
+
+    /// @notice Error emitted when the balance is insufficient
+    error INSUFFICIENT_BALANCE();
+
+    /// @notice Error emitted when the token is not allowed
+    error TOKEN_NOT_ALLOWED(address token);
+
+    /// @notice Event emitted when a token is added or removed
+    /// @param token address of the token
+    /// @param supported struct with deposit and withdraw booleans
+    event SupportedToken(address indexed token, Supported supported);
+
+    /// @notice Event emitted when a deposit is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the deposit
+    event Deposit(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Event emitted when a withdrawal is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the withdrawal
+    event Withdraw(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Method to deposit tokens
+    /// @dev token are transferred from the sender, and the receiver is credited
+    /// @param _token address of the token
+    /// @param _amount amount to deposit
+    /// @param _receiver address of the receiver
+    function deposit(address _token, uint256 _amount, address _receiver) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev difference between balance and internal balance is transferred to the owner
+    /// @param _token address of the token
+    function rescueERC20(address _token) external;
+
+    /// @notice Method to add or remove a token
+    /// @dev only callable by the owner
+    /// @param _token address of the token
+    /// @param _supported struct with deposit and withdraw booleans
+    function supportToken(address _token, Supported calldata _supported) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev token are transferred to the receiver and sender is credited
+    /// @param _token address of the token
+    /// @param _amount amount to withdraw
+    /// @param _receiver address of the receiver
+    function withdraw(address _token, uint256 _amount, address _receiver) external;
+}

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "../interfaces/IPPausingInterface.sol";
+import "../interfaces/IPGovernanceProxy.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+// solhint-disable custom-errors
+// solhint-disable no-inline-assembly
+// solhint-disable no-empty-blocks
+
+contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPGovernanceProxy {
+    bytes32 public constant GUARDIAN = keccak256("GUARDIAN");
+
+    modifier onlyGuardian() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(GUARDIAN, msg.sender), "not authorized");
+        _;
+    }
+
+    modifier onlyAdmin() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not authorized");
+        _;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                PAUSING
+    //////////////////////////////////////////////////////////////*/
+
+    function pause(address[] calldata addrs) external onlyGuardian {
+        uint256 length = addrs.length;
+        for (uint256 i = 0; i < length; ) {
+            IPPausingInterface(addrs[i]).pause();
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            ADMIN CALL
+    //////////////////////////////////////////////////////////////*/
+
+    function aggregate(
+        IPGovernanceProxy.Call[] calldata calls
+    ) external payable onlyAdmin returns (bytes[] memory rtnData) {
+        uint256 length = calls.length;
+        rtnData = new bytes[](length);
+
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{value: call.value}(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            rtnData[i] = resp;
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function initialize(address governance) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, governance);
+    }
+
+    function _authorizeUpgrade(address) internal view override onlyAdmin {}
+}

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -114,12 +114,20 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     function getLpToAssetRate(address market) public view returns (uint256) {
         MarketState memory state = _readState(market);
         PYIndex pyIndexCurrent = _pyIndex(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
 
-        int256 totalHypotheticalAsset = comp.totalAsset +
-            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        int256 totalHypotheticalAsset;
+        if (state.expiry <= block.timestamp) {
+            // 1 PT = 1 Asset post-expiry
+            totalHypotheticalAsset = state.totalPt + pyIndexCurrent.syToAsset(state.totalSy);
+        } else {
+            MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
+
+            totalHypotheticalAsset =
+                comp.totalAsset +
+                state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        }
 
-        return uint256(totalHypotheticalAsset.divDown(state.totalLp));
+        return totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
     function getPtToAssetRate(address market) public view returns (uint256) {

package/contracts/router/ActionMiscV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionMiscV3.sol";
+import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     function mintSyFromToken(
@@ -116,10 +117,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
-    // TODO: need to allow exit to SY as well
-    // TODO: check against minOut
-    // double check event orders
-
     function exitPreExpToToken(
         address receiver,
         address market,
@@ -173,7 +170,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
 
         if (netPtIn > 0) {
-            _transferIn(address(PT), address(this), netPtIn);
+            _transferIn(address(PT), msg.sender, netPtIn);
         }
 
         p.netPyRedeem = PMath.min(p.netPtFromRemove + netPtIn, netYtIn);
@@ -269,8 +266,37 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
     }
 
+    function callAndReflect(
+        address payable reflector,
+        bytes calldata selfCall1,
+        bytes calldata selfCall2,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes) {
+        (, selfRes1) = _delegateToSelf(selfCall1, false);
+        if (selfCall2.length > 0) (, selfRes2) = _delegateToSelf(selfCall2, false);
+        reflectRes = _callToReflector(reflector, reflectCall);
+    }
+
     function simulate(address target, bytes calldata data) external payable {
         (bool success, bytes memory result) = target.delegatecall(data);
         revert Errors.SimulationResults(success, result);
     }
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    function _callToReflector(address payable reflector, bytes memory data) internal returns (bytes memory) {
+        return IPReflector(reflector).reflect(data);
+    }
 }

package/contracts/router/Reflector.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPAllActionV3.sol";
+import "../interfaces/IPReflector.sol";
+import "../core/libraries/TokenHelper.sol";
+
+contract Reflector is TokenHelper, IPReflector {
+    using SafeERC20 for IERC20;
+
+    mapping(address => bool) internal approved;
+
+    receive() external payable {}
+
+    function reflect(bytes calldata inputData) external returns (bytes memory result) {
+        (uint256 value, bytes memory newCalldata) = _getNewCalldata(inputData);
+        bool success;
+
+        (success, result) = msg.sender.call{value: value}(newCalldata);
+        if (!success) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    function _getNewCalldata(bytes calldata inputData) internal returns (uint256 value, bytes memory newCalldata) {
+        bytes4 selector = bytes4(inputData[:4]);
+        bytes calldata data = inputData[4:];
+
+        if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleToken.selector) {
+            (
+                address v1,
+                address v2,
+                uint256 v3,
+                ApproxParams memory v4,
+                TokenInput memory v5,
+                LimitOrderData memory v6
+            ) = abi.decode(data, (address, address, uint256, ApproxParams, TokenInput, LimitOrderData));
+
+            value = _scaleTokenInputAndGetValue(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5, v6);
+        } else if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleTokenKeepYt.selector) {
+            (address v1, address v2, uint256 v3, uint256 v4, TokenInput memory v5) = abi.decode(
+                data,
+                (address, address, uint256, uint256, TokenInput)
+            );
+
+            value = _scaleTokenInputAndGetValue(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5);
+        } else {
+            revert("UNSUPPORTED_SELECTOR");
+        }
+    }
+
+    function _scaleTokenInputAndGetValue(TokenInput memory inp) internal returns (uint256 ethValue) {
+        require(inp.swapData.swapType == SwapType.NONE, "SWAP_NOT_ALLOWED"); // the exit call should already swap
+
+        inp.netTokenIn = _selfBalance(inp.tokenIn);
+
+        if (inp.tokenIn == NATIVE) {
+            ethValue = inp.netTokenIn;
+        } else if (!approved[inp.tokenIn]) {
+            IERC20(inp.tokenIn).forceApprove(msg.sender, type(uint256).max);
+            approved[inp.tokenIn] = true;
+        }
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -373,20 +373,4 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }
-
-    // ----------------- DELEGATE CALL -----------------
-
-    function _delegateToSelf(
-        bytes memory data,
-        bool allowFailure
-    ) internal returns (bool success, bytes memory result) {
-        (success, result) = address(this).delegatecall(data);
-
-        if (!success && !allowFailure) {
-            assembly {
-                // We use Yul's revert() to bubble up errors from the target contract.
-                revert(add(32, result), mload(result))
-            }
-        }
-    }
 }

package/deployments/1-markets/EZETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x22E12A50e3ca49FB183074235cB1db84Fe4C716D",
+    "YT": "0x1623F1A991584A6b69baBbdbffD26E2B46485465",
+    "PT": "0x248241244356D18f63d0c16082996839ecB0C7bF",
+    "market": "0xcDBD5ff3E03b6828Db9C32e2131A60ABA5137901",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/PUFETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY pufETH",
+    "SY": "0x253008ba4aE2f3E6488DC998a5321D4EB1a0c905",
+    "YT": "0x1a65eB80a2ac3ea6E41D456DdD6E9cC5728BEf7C",
+    "PT": "0xd4e75971eAF78a8d93D96df530f1FFf5f9F53288",
+    "market": "0xA54FC268101c8b97DE19eF3141d34751a11996B2",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/RSETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0xE653E4048620E546AFff02D3689678896d22e236",
+    "PT": "0x7bAf258049cc8B9A78097723dc19a8b103D4098F",
+    "market": "0x6b4740722e46048874d84306B2877600ABCea3Ae",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/RSWETH-SWELL-STAKING-MAINNET-JUL2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rswETH",
+    "SY": "0x4f3A7a07A968B67F1f9692b70242f10E665d38Ad",
+    "YT": "0xf0E4244Ca93Ac36752DA5939Afd9CB73B0637b06",
+    "PT": "0x0a0E172511114456EC63A85FF32E45C5e0E27D63",
+    "market": "0x1e0c2e41f3165ff6B8a660092f63E10BC0EebE26",
+    "expiry": 1721865600,
+    "scalarRoot": "8113474588000000000",
+    "initAnchor": "1061316437000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/SUSDE-MAINNET-SEP2024.json

@@ -0,0 +1,13 @@
+{
+    "name": "SUSDE-MAINNET-SEP2024",
+    "SY": "0x4139cDC6345aFFbaC0692b43bed4D059Df3e6d65",
+    "YT": "0xdc02b77a3986da62C7A78FED73949C9767850809",
+    "PT": "0x6c9f097e044506712B58EAC670c9a5fd4BCceF13",
+    "market": "0xd1D7D99764f8a52Aff007b7831cc02748b2013b5",
+    "expiry": 1727308800,
+    "lnFeeRateRoot": "2995508979000000",
+    "scalarRoot": "8580934398000000000",
+    "initAnchor": "1120006408000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0x467c0c15148778d0b99a1d9f3bd7406fd0c58d8a6e3284a57a50e55ae0160165"
+}

package/deployments/1-markets/UNIETH-MAINNET-SEP2024.json

@@ -0,0 +1,13 @@
+{
+    "name": "UNIETH-MAINNET-SEP2024",
+    "SY": "0xc430dB19339A3051192233B4c49f9aB3DC6D16b7",
+    "YT": "0xdF74bA4436478969A54eCB352093312fE97EBAa5",
+    "PT": "0x15fA86404BFbA8b46684552F792558128bFB6418",
+    "market": "0xBaE2Df4DfCd0c613018D6056A40077F2d1eFf28A",
+    "expiry": 1727308800,
+    "lnFeeRateRoot": "2995508979000000",
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0x4e509feb8502bee0c719c1a9eb2c73c9e1b070fc8424e1f4f31618bdc764a560"
+}

package/deployments/1-markets/WEETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0xAC0047886a985071476a1186bE89222659970d65",
+    "YT": "0xA54Df645A042D24121a737dAA89a57EbF8E0b71c",
+    "PT": "0x1c085195437738d73d75DC64bC5A3E098b7f93b1",
+    "market": "0xC8eDd52D0502Aa8b4D5C77361D4B3D300e8fC81c",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/42161-core.json

@@ -19,7 +19,7 @@
     "PENDLE": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
     "yieldContractFactory": "0x28dE02Ac3c3F5ef427e55c321F73fDc7F192e8E4",
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
-    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "router": "0xaBbCC1E99687b2d5B6db8bC5dD8904B142Eaf04b",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
     "pendleSwap": "0x63a45E0B2686F7be77Bb85735c35704D1046459a",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",

package/deployments/42161-markets/EZETH-ARB-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x0dE802e3D6Cc9145A150bBDc8da9F988a98c5202",
+    "YT": "0xE58AfaA6E2abF9A9F243D5A55Bd5447628c4D811",
+    "PT": "0x2CCFce9bE49465CC6f947b5F6aC9383673733Da9",
+    "market": "0x35f3dB08a6e9cB4391348b0B404F493E7ae264c0",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/42161-markets/RSETH-ARBITRUM-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "YT": "0x2FDc424946AA72D42E2F897447d7c335E64845F0",
+    "PT": "0x30c98c0139B62290E26aC2a2158AC341Dcaf1333",
+    "market": "0x1d38d4204159aA5e767aFbA8f76BE22117De61E5",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "29999550000000"
+}

package/deployments/42161-markets/SILO-PTEETH-ARBITRUM-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY sETH-pteETHSilo",
+    "SY": "0xd0c4351a18F40b96b6446Da3A191496DF36d60F9",
+    "YT": "0x7Cfb81E9c9402D48c6F3161204a21800b210BAeA",
+    "PT": "0x2D5405688f253D741a9F1090DD90D8A285CF5C79",
+    "market": "0x6aBE9Ac2df48490693BdB9d66Fa898fc9cD7cc36",
+    "expiry": 1719446400,
+    "scalarRoot": "10324763686000000000",
+    "initAnchor": "1041846750000000000",
+    "lnFeeRateRoot": "499875041000000"
+}