項目介紹

Pendle 官方網站：https://www.pendle.finance/
Pendle Finance 是一種無需許可的收益交易協議，用戶可以在其中執行各種收益管理策略，通過將 DeFi 上的生息資產拆分成 PT（本金代幣）和 YT（收益代幣）來實現上述功能。

將 1 ETH 質押成 1 stETH，年利率為 5%，那么到期后 1 stETH 就能收回 1 ETH（本金）+ 0.05 ETH（收益）。而 Pendle 所做的就是把 1 stETH 代表的生息代幣（SY），拆分成了本金（Principal）和收益（Yield）兩部分，使其可以分別流通于市場上。

YT 和 PT 的定義：

1. YT (Yield Token) -> 代表該倉位的應收收益：1 YT 使您有權在到期前獲得 1 單位標的資產（例如 1 ETH、1 DAI、1 USDe 等）的收益，并可實時索取。
2. PT（Principal Token）->代表本金金額：1 PT 賦予您在到期時贖回 1 單位標的資產（例如 1 ETH、1 DAI、1 USDe 等）的權利。

用戶可以將生息代幣（1 stETH）拆分成 PT 和 YT ，然后使其在市場上流通。也可以通過存入等量的 PT 和 YT 來贖回標的資產。到期后，PT 可以贖回其標的資產（1 ETH），無需對應的 YT（這是因為到期的 YT 價值為 0，因為它們不再產生收益）。

本篇文章分析時用的代碼版本是：https://github.com/pendle-finance/pendle-core-v2-public/tree/260e8d3a807ae2bd195a77cdefb869f494c53ebb

流動性池

在項目介紹章節，有提到過 PT 和 YT 可以分別流通于市場上，也可以存入等量的 PT 和 YT 兌換成 SY。為了實現上面提到的功能，Pendle 實現了一個基于 [SY, PT] 的 AMM Pool，用戶可以通過它來兌換 SY，PT，YT 三種資產（很奇妙吧，一個 pair 兌換三種資產）。

由于到期后 PT 的價值和 SY 的價值是相等的，所以在 [SY, PT] Pool 中添加流動性可以被認為在到期后不會產生無常損失。

Pendle 收益代幣化的核心是將收益代幣拆分為 PT 和 YT。兩種代幣的價格相加就是基礎資產的價格。因此，PT和YT的價格一定是負相關的——YT價格越高，PT價格越低，反之亦然。

那么，到底是怎么樣通過 [SY, PT] Pool 來進行 PT/SY → YT 的兌換呢？官方文檔給出了下面的描述：

1. 買方將 PT/SY 發送到 Router 中
2. Router 從池中閃電貸出 SY
3. 將這筆 SY 鑄造成 PT + YT
4. 將 YT 發送給買家
5. 將 PT 出售兌換成 SY，以返還步驟 2 中的閃電貸

轉換成公式表達

Input:      
					= x * PT
Flashloan SY: 
					= x * PT + y * SY
					= x * PT + y * (PT + YT)
					= (x + y) * PT + y * YT
Sell to repay flashloan:
					= y * YT
Output:
					= y * YT

===================================

In flashloan:
					y * SY = (x + y) * PT

基于上面的公式，x 作為輸入的 PT 數量，計算出 YT 的輸出數量 y。

那么這個計算過程是怎么通過實現的？在 Pendle 的代碼實現中沒有通過公式計算，而是采用了二分查找法直接找出 y 的值（沒想到吧）。

PT → YT 的合約入口：

contracts/router/ActionSwapYTV3.sol

// ------------------ SWAP PT FOR YT ------------------

    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
    function swapExactPtForYt(
        address receiver,
        address market,
        uint256 exactPtIn,   **// @note `x` amount**
        uint256 minYtOut,
        ApproxParams calldata guessTotalPtToSwap
    ) external returns (uint256 netYtOut, uint256 netSyFee) {
        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();

        uint256 totalPtToSwap;
        
        **// @note `y` == netYtOut, `x + y` == totalPtToSwap**
        (netYtOut, totalPtToSwap, netSyFee) = _readMarket(market).approxSwapExactPtForYt(
            YT.newIndex(),
            exactPtIn,
            block.timestamp,
            guessTotalPtToSwap
        );

        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);

				**// @note swap PT to `receiver`**
        IPMarket(market).swapExactPtForSy(
            address(YT),
            totalPtToSwap,
            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
        );

        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
    }

contracts/router/math/MarketApproxLib.sol

/**
 * @dev algorithm:
 *     - Bin search the amount of PT to swap to SY
 *     - Flashswap the corresponding amount of SY out
 *     - Tokenize all the SY into PT + YT
 *     - PT to repay the flashswap, YT transferred to user
 *     - Stop when the additional amount of PT to pull to repay the loan approx the exactPtIn
 *     - guess & approx is for totalPtToSwap
 */
function approxSwapExactPtForYt(
    MarketState memory market,
    PYIndex index,
    uint256 exactPtIn,
    uint256 blockTime,
    ApproxParams memory approx
) internal pure returns (uint256, /*netYtOut*/ uint256, /*totalPtToSwap*/ uint256 /*netSyFee*/) {
    MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
    
    **// @note `guessOffchain` is the value of `y` calculated offline**
    **// @note `approx` is the upper and lower limits of the binary search**
    if (approx.guessOffchain == 0) {
        approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
        approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
        validateApprox(approx);
    }

		**// @note binary search**
    for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
        uint256 guess = nextGuess(approx, iter);    **// @note `guess` == (x + y) ?**
			  
			  **// @note (x + y) * PT -> y * SY**
	      (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);  
				
				**// @note calculate the actual vaule of SY (becasuse its value will change with the change of `index`)
				// @note `netAssetOut` == y ?**
        uint256 netAssetOut = index.syToAsset(netSyOut);

        // guess >= netAssetOut since we are swapping PT to SY
        uint256 netPtToPull = guess - netAssetOut;  **// @note `netPtToPull` == x ?**

        if (netPtToPull <= exactPtIn) {
		        **// @note if the gap of `netPtToPull` and `x` is acceptable** 
            if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps)) {
		            **// @note `y` == `netAssetOut`, `x + y` == `guess`**  
                return (netAssetOut, guess, netSyFee);
            }
            approx.guessMin = guess;
        } else {
            approx.guessMax = guess - 1;
        }
    }
    revert("Slippage: APPROX_EXHAUSTED");
}

當然除了 PT → YT，Pendle 還支持 SY，PT，YT 三種代幣兩兩互相交換，在 contracts/router 目錄下可以找到每種兌換方式的實現。讀者感興趣可以自行了解。

為什么采用 netAssetOut 來計算 PT 的數量，而不是直接采用 SY 來計算？

在 approxSwapExactPtForYt 函數中，通過 uint256 netAssetOut = index.syToAsset(netSyOut); 將 SY 的數量 netSyOut 轉換成了 Asset 的數量 netAssetOut ，然后再計算出所需要的 PT 數量 netPtToPull。

PT 是代表到期贖回本金權利的代幣，到期后按照 PT : Asset = 1 : 1 的比例進行贖回。而 SY 包含了收益部分，其價值會隨著時間的增加而增加。所以在計算 PT 數量的時候選擇將 SY 換算成 Asset 進行計算，是為了統一計算單位。

官方例子：https://docs.pendle.finance/Developers/HighLevelArchitecture#principal-token-pt

At redemption, 1 PT = X SY, where X satisfies the condition that X SY = 1 Asset. For example, assuming 1 wstETH = 1.2 stETH on 1/1/2024, 1 PT-wstETH-01JAN2024 will be redeemable to 0.8928 wstETH at maturity.

用戶可以向流動性池子添加流動性，以通過多種途徑獲得收益：

1. 基礎資產的協議收益/獎勵
2. 池中 PT 部分的固定收益（添加流動性時將以折扣價格買入 PT）
3. Swap fees
4. $PENDLE 激勵

經濟模型

用戶可以將添加流動性或其他渠道獲得的 PENDLE 代幣進行鎖定，得到 vePENDLE 代幣，而這個代幣將在 Pendle 的治理與收益分配中起到重要作用。整個 Pendle 的經濟模型如下圖所示。

用戶可以將手里的 PENDLE 通過 VotingEscrowPendleMainchain 合約進行鎖定，合約會將用戶的鎖定時間和代幣數量記錄到 position 中。vePENDLE 不具有流動性，這在鎖定期到期之前它無法轉移。

contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

在獲得 vePENDLE 后，用戶可以通過 PendleVotingControllerUpg 合約向池子進行投票。

contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

使用 vePENDLE 進行投票將獲得的收益：

1. 將 $PENDLE 激勵投入流動性池
2. 獲得投票池 swap fee：
   1. vePENDLE 投票者能夠從投票池中獲得 80% 的 swap fee
3. 接收基礎APY
   1. Pendle 從 YT 累積的所有收益（包括積分）中收取 3% 的費用。目前，該費用 100% 分配給 vePENDLE 持有者
   2. 到期未贖回 PT 的部分收益也將按比例分配給 vePENDLE 持有者。
4. 增加 LP 獎勵（高達 250%）：
   1. 如果您在持有 vePENDLE 的同時將 LP 加入到池中，那么您所有 LP 的 PENDLE 激勵和獎勵也將進一步增加，根據您的 vePENDLE 價值最多可增加 250%。

由于 vePENDLE 投票可以給投票用戶帶來收益，那么為了將這個收益最大化，需要有組織地對 vePENDLE 代幣進行投票操作。由此衍生出了一批在 Pendle 基礎上建立起來的 DeFi 協議：Penpie、Equilibria 和 StakeDAO 等。

簡單介紹一下其中一個平臺 Penpie

官方文檔：https://docs.penpiexyz.io/penpie-ecosystem/introduction

Penpie 是 Magpie 在 Pendle Finance 基礎上打造的一個為 Pendle 用戶提供收益提升服務的 DeFi 平臺。
Penpie 為 PENDLE 持有者提供通過 PENDLE 轉換為 mPENDLE 來賺取可觀收益。用戶可以通過 Penpie 質押 mPENDLE，以獲得平臺上增強的活躍用戶參與獎勵。當用戶將其 PENDLE 轉換為 mPENDLE 時，Penpie 會自動將轉換后的 PENDLE 在 Pendle Finance 中鎖定為 vePENDLE。這一機制使 PENDLE 持有者能夠通過 mPENDLE 獲得更大的獎勵，同時還授予 Penpie 治理權，并作為 Pendle Finance 的流動性提供者獲得更高的年化利率 (APR%)。由于 Penpie 持有 vePENDLE，流動性提供者可以將資產存入平臺并賺取提升的 PENDLE，而無需自己將任何 PENDLE 鎖定為 vePENDLE。

Penpie 平臺在為用戶帶來更高收益的同時，也遭受了項目攻擊的風險。詳情可見：【漏洞分析】Penpie 攻擊事件：重入攻擊構造獎勵金額

這種在 DeFi 上建立 DeFi 的做法無疑是為用戶帶來了更高的收益，但是由于用戶資金在投資過程中涉及的項目增加，遭受合約漏洞攻擊而產生資金損失的風險也隨之增大。在投資過程中選擇經過專業安全審計機構審計過的項目十分重要。那么安全審計哪家強？!【此處招商，價格公道，童叟無欺！】