@pendle/core-v2 4.4.4 → 4.4.6

package/build/artifacts/contracts/interfaces/Tensorplex/ITensorplexStTAO.sol/ITensorplexStTAO.dbg.json

@@ -0,0 +1,4 @@
+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../../../build-info/ad9ac6854c41428acf31f0023b148bc0.json"
+}

package/build/artifacts/contracts/interfaces/Tensorplex/ITensorplexStTAO.sol/ITensorplexStTAO.json

@@ -0,0 +1,106 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "ITensorplexStTAO",
+  "sourceName": "contracts/interfaces/Tensorplex/ITensorplexStTAO.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "wtaoAmount",
+          "type": "uint256"
+        }
+      ],
+      "name": "calculateAmtAfterFee",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "exchangeRate",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "wtaoAmount",
+          "type": "uint256"
+        }
+      ],
+      "name": "getWstTAObyWTAO",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "maxTaoForWrap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "wtaoAmount",
+          "type": "uint256"
+        }
+      ],
+      "name": "wrap",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "wrappedToken",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/core/StandardizedYield/implementations/Ethena/{PendleUSDEMantleSY.sol → PendleUSDEL2SY.sol}

@@ -3,7 +3,7 @@ pragma solidity ^0.8.17;
 
 import "../PendleERC20SYUpg.sol";
 
-contract PendleUSDEMantleSY is PendleERC20SYUpg {
+contract PendleUSDEL2SY is PendleERC20SYUpg {
     uint256 public supplyCap;
 
     event SupplyCapUpdated(uint256 newSupplyCap);
@@ -19,7 +19,6 @@ contract PendleUSDEMantleSY is PendleERC20SYUpg {
         _updateSupplyCap(_initialSupplyCap);
     }
 
-
     function _previewDeposit(
         address /*tokenIn*/,
         uint256 amountTokenToDeposit

package/contracts/core/StandardizedYield/implementations/Tensorplex/PendleStTAOSY.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/Tensorplex/ITensorplexStTAO.sol";
+
+// wTAO can be modified on stTAO contract on very unlikely special occasions.
+// However in such case, depositing using stTAO should still be feasible so making wTAO address mutable is not worth the gas cost of users.
+
+// @notice: stTAO and wstTAO is the same one.
+// Tensorplex use wstTAO for naming convention on contract writing and stTAO for the name of the token
+
+contract PendleStTAOSY is SYBaseUpg {
+    using PMath for uint256;
+
+    error MaxStTAOSupplyExceeded(uint256 amountTaoToWrap, uint256 maxTaoForWrap);
+
+    // solhint-disable immutable-vars-naming
+    address public immutable stTAO;
+    address public immutable wTAO;
+
+    constructor(address _stTAO) SYBaseUpg(_stTAO) {
+        _disableInitializers();
+        stTAO = _stTAO;
+        wTAO = ITensorplexStTAO(stTAO).wrappedToken();
+    }
+
+    function initialize() initializer external {
+        __SYBaseUpg_init("SY Tensorplex Staked TAO", "SY-stTAO");
+        _safeApproveInf(wTAO, stTAO);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == stTAO) {
+            return amountDeposited;
+        }
+        uint256 preBalance = _selfBalance(stTAO);
+        ITensorplexStTAO(stTAO).wrap(amountDeposited);
+        return _selfBalance(stTAO) - preBalance;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(stTAO, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE.divDown(ITensorplexStTAO(stTAO).exchangeRate());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == stTAO) {
+            return amountTokenToDeposit;
+        }
+
+        uint256 maxTaoForWrap = ITensorplexStTAO(stTAO).maxTaoForWrap();
+        if (amountTokenToDeposit > maxTaoForWrap) {
+            revert MaxStTAOSupplyExceeded(amountTokenToDeposit, maxTaoForWrap);
+        }
+
+        (uint256 amountWTaoAfterFee, ) = ITensorplexStTAO(stTAO).calculateAmtAfterFee(amountTokenToDeposit);
+        return ITensorplexStTAO(stTAO).getWstTAObyWTAO(amountWTaoAfterFee);
+    }
+
+    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(wTAO, stTAO);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(stTAO);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == wTAO || token == stTAO;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stTAO;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, wTAO, IERC20Metadata(wTAO).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zircuit/{PendleZtakeWETHSY.sol → PendleZtakeERC20SY.sol}

@@ -4,20 +4,20 @@ pragma solidity ^0.8.17;
 import "../../SYBaseUpg.sol";
 import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
 
-contract PendleZtakeWETHSY is SYBaseUpg {
+contract PendleZtakeERC20SY is SYBaseUpg {
     // solhint-disable immutable-vars-naming
     address public immutable zircuitStaking;
-    address public immutable wETH;
+    address public immutable asset;
 
-    constructor(address _zircuitStaking, address _wETH) SYBaseUpg(_wETH) {
+    constructor(address _zircuitStaking, address _asset) SYBaseUpg(_asset) {
         _disableInitializers();
         zircuitStaking = _zircuitStaking;
-        wETH = _wETH;
+        asset = _asset;
     }
 
-    function initialize() external initializer {
-        __SYBaseUpg_init("SY Zircuit Staking wETH", "SY-zs-wETH");
-        _safeApproveInf(wETH, zircuitStaking);
+    function initialize(string memory name, string memory symbol) external initializer {
+        __SYBaseUpg_init(name, symbol);
+        _safeApproveInf(asset, zircuitStaking);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -25,7 +25,7 @@ contract PendleZtakeWETHSY is SYBaseUpg {
     //////////////////////////////////////////////////////////////*/
 
     function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
-        IZircuitZtaking(zircuitStaking).depositFor(wETH, address(this), amountDeposited);
+        IZircuitZtaking(zircuitStaking).depositFor(asset, address(this), amountDeposited);
         return amountDeposited;
     }
 
@@ -34,8 +34,8 @@ contract PendleZtakeWETHSY is SYBaseUpg {
         address /*tokenOut*/,
         uint256 amountSharesToRedeem
     ) internal override returns (uint256 /*amountTokenOut*/) {
-        IZircuitZtaking(zircuitStaking).withdraw(wETH, amountSharesToRedeem);
-        _transferOut(wETH, receiver, amountSharesToRedeem);
+        IZircuitZtaking(zircuitStaking).withdraw(asset, amountSharesToRedeem);
+        _transferOut(asset, receiver, amountSharesToRedeem);
         return amountSharesToRedeem;
     }
 
@@ -66,24 +66,24 @@ contract PendleZtakeWETHSY is SYBaseUpg {
     }
 
     function getTokensIn() public view override returns (address[] memory res) {
-        return ArrayLib.create(wETH);
+        return ArrayLib.create(asset);
     }
 
     function getTokensOut() public view override returns (address[] memory res) {
-        return ArrayLib.create(wETH);
+        return ArrayLib.create(asset);
     }
 
     function isValidTokenIn(address token) public view override returns (bool) {
-        return token == wETH;
+        return token == asset;
     }
 
     function isValidTokenOut(address token) public view override returns (bool) {
-        return token == wETH;
+        return token == asset;
     }
 
     function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         assetType = AssetType.TOKEN;
-        assetAddress = wETH;
-        assetDecimals = 18;
+        assetAddress = asset;
+        assetDecimals = IERC20Metadata(asset).decimals();
     }
 }

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeUSDESY.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
+
+contract PendleZtakeUSDESY is SYBaseUpg {
+    // solhint-disable immutable-vars-naming
+    address public immutable zircuitStaking;
+    address public immutable usde;
+
+    // Supply cap might be updated more often than on special occasion. Leave it as normal storage for better conveinence.
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(address _zircuitStaking, address _usde) SYBaseUpg(_usde) {
+        _disableInitializers();
+        zircuitStaking = _zircuitStaking;
+        usde = _usde;
+    }
+
+    function initialize(uint256 _initialSupplyCap) external initializer {
+        __SYBaseUpg_init("SY Zircuit Staking USDe", "SY-zs-USDe");
+        _safeApproveInf(usde, zircuitStaking);
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
+        IZircuitZtaking(zircuitStaking).depositFor(usde, address(this), amountDeposited);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        IZircuitZtaking(zircuitStaking).withdraw(usde, amountSharesToRedeem);
+        _transferOut(usde, receiver, amountSharesToRedeem);
+        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 /*amountSharesOut*/) {
+        uint256 _newSupply = totalSupply() + amountTokenToDeposit;
+        uint256 _supplyCap = supplyCap;
+
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                SUPPLY CAP RELATED FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    // @dev: whenNotPaused not needed as it has already been added to beforeTransfer
+    function _afterTokenTransfer(address from, address, uint256) internal virtual override {
+        // only check for minting case
+        // saving gas on user->user transfers
+        // skip supply cap checking on burn to allow lowering supply cap
+        if (from != address(0)) {
+            return;
+        }
+
+        uint256 _supply = totalSupply();
+        uint256 _supplyCap = supplyCap;
+        if (_supply > _supplyCap) {
+            revert SupplyCapExceeded(_supply, _supplyCap);
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(usde);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(usde);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == usde;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == usde;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        assetType = AssetType.TOKEN;
+        assetAddress = usde;
+        assetDecimals = IERC20Metadata(usde).decimals();
+    }
+}

package/contracts/interfaces/Tensorplex/ITensorplexStTAO.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ITensorplexStTAO {
+    function wrappedToken() external view returns (address);
+
+    function wrap(uint256 wtaoAmount) external;
+
+    function exchangeRate() external view returns (uint256);
+
+    function maxTaoForWrap() external view returns (uint256);
+
+    function calculateAmtAfterFee(uint256 wtaoAmount) external view returns (uint256, uint256);
+
+    function getWstTAObyWTAO(uint256 wtaoAmount) external view returns (uint256);
+}

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

@@ -0,0 +1,13 @@
+{
+    "name": "STTAO-JUNE2024",
+    "SY": "0x60CceFd60bA522f9221f122BB80A1e8cbAB9285F",
+    "YT": "0x233D32d4D33eD5F2D6b8544137c8836249de372F",
+    "PT": "0x5282Ec643C3790E0F781508162a4Aa13fd09C528",
+    "market": "0x2084b373979415Bc93190071AF3390F92DcDD189",
+    "expiry": 1719446400,
+    "lnFeeRateRoot": "9950330853000000",
+    "scalarRoot": "2097143853000000000",
+    "initAnchor": "1249220799000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0xc7b0a026346cd4dae528e85ad21ab019c84e80cebe1b9b65be7683c4e02618bb"
+}

package/deployments/1-markets/ZIRCUIT-USDE-JUNE2024.json

@@ -0,0 +1,13 @@
+{
+    "name": "ZIRCUIT-USDE-JUNE2024",
+    "SY": "0x293C6937D8D82e05B01335F7B33FBA0c8e256E30",
+    "YT": "0x40357b9f22B4DfF0Bf56A90661b8eC106C259d29",
+    "PT": "0x3d4F535539A33FEAd4D76D7b3B7A9cB5B21C73f1",
+    "market": "0x90c98ab215498B72Abfec04c651e2e496bA364C0",
+    "expiry": 1719446400,
+    "lnFeeRateRoot": "9950330853000000",
+    "scalarRoot": "1422786054000000000",
+    "initAnchor": "1371644990000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0xcc9b9e5433c77f24cc9b4095d7367805672656c0884d2ad8283ca54dc47461e8"
+}

package/deployments/1-offchain-helper.json

@@ -1,5 +1,6 @@
 {
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
-    "implicitSwapfeeContract": "0x43D03031FAb845065e9CEfE89Dd122d63F72011F"
+    "implicitSwapfeeContract": "0x43D03031FAb845065e9CEfE89Dd122d63F72011F",
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
 }

package/deployments/10-offchain-helper.json

@@ -1,4 +1,5 @@
 {
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
-    "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C"
+    "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
 }

package/deployments/42161-markets/USDE-ARBITRUM-AUG2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY USDe",
+    "SY": "0xb3C24D9dcCC2Ec5f778742389ffe448E295B84e0",
+    "YT": "0xF478f7FeaeAB0DFdC91E02cDd6C63c66E30a7335",
+    "PT": "0xad853EB4fB3Fe4a66CdFCD7b75922a0494955292",
+    "market": "0x2Dfaf9a5E4F293BceedE49f2dBa29aACDD88E0C4",
+    "expiry": 1724889600,
+    "scalarRoot": "1120571444000000000",
+    "initAnchor": "1821342325000000000",
+    "lnFeeRateRoot": "9950330853000000"
+}

package/deployments/42161-offchain-helper.json

@@ -1,5 +1,6 @@
 {
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
-    "implicitSwapfeeContract": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0"
+    "implicitSwapfeeContract": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
 }

package/deployments/5000-offchain-helper.json

@@ -1,5 +1,6 @@
 {
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
-    "implicitSwapfeeContract": "0xa87f7EeDD570943BcFFcE6D00B13D9a95ede8810"
+    "implicitSwapfeeContract": "0xa87f7EeDD570943BcFFcE6D00B13D9a95ede8810",
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
 }

package/deployments/56-offchain-helper.json

@@ -1,5 +1,6 @@
 {
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
-    "implicitSwapfeeContract": "0xed18de5442297a4ec1ce59c7c7d9427adc2a012b"
+    "implicitSwapfeeContract": "0xed18de5442297a4ec1ce59c7c7d9427adc2a012b",
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "4.4.4",
+  "version": "4.4.6",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",