<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Louis Noh on Medium]]></title>
        <description><![CDATA[Stories by Louis Noh on Medium]]></description>
        <link>https://medium.com/@voidgun93?source=rss-2233b8292fe7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*aZ8rMNoP20S8PmbMyqRZMQ.jpeg</url>
            <title>Stories by Louis Noh on Medium</title>
            <link>https://medium.com/@voidgun93?source=rss-2233b8292fe7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:32:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@voidgun93/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[TON vs Ethereum]]></title>
            <link>https://medium.com/@voidgun93/ton-vs-ethereum-5dce3b75036c?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/5dce3b75036c</guid>
            <category><![CDATA[ton]]></category>
            <category><![CDATA[telegram]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Wed, 28 Aug 2024 05:36:45 GMT</pubDate>
            <atom:updated>2024-08-28T05:43:17.457Z</atom:updated>
            <content:encoded><![CDATA[<h3>스마트 컨트랙트의 비용 모델</h3><ul><li>컨트랙트는 TON 잔액을 유지해야 하며, 부족 시 삭제될 수 있습니다.</li><li>개발자는 다양한 운영 자금 조달 방법을 선택할 수 있습니다.</li><li>이더리움은 트랜잭션을 발생시킨 사용자가 가스비를 지불</li><li>그렇다면, 체인에 저장된 데이터를 유지하는 건 miner</li><li>이러한 시스템은 수십억명의 이용자가 있다면, 붕괴될 것</li><li>TON은 지구상의 모든 인간의 손에 블록체인을 제공하도록 목표를 설정</li><li>따라서, 은행 모델이 아닌 메시지 플랫폼 모델을 채용</li></ul><p>TON은 메시지 플랫폼 모델을 채택하여 dapp 제공자가 비용을 지불합니다.</p><ul><li>컨트랙트는 TON 잔액을 유지해야 하며, 부족 시 삭제될 수 있습니다.</li><li>개발자는 다양한 운영 자금 조달 방법을 선택할 수 있습니다.</li><li>메시지 플랫폼은 사용자가 아닌 플랫폼 제공자가 비용을 지불</li><li>즉, TON에서는 Dapp 제공자가 비용을 지불</li></ul><h3>호출 방식 비교</h3><p>이더리움의 컨트랙트 호출은 아래의 특징을 가지고 있음</p><ul><li>한 트랜잭션이 여러 컨트랙트와 상호작용이 가능하고, 하나라도 실패시 전체가 롤백</li><li>컨트랙트가 다른 컨트랙트 메서드를 실행하면 동일 트랜잭션에서 즉시 처리 -&gt; 단일 서버의 백엔드와 유사</li></ul><p>TON의 컨트랙트 호출은 마이크로 서비스 클러스터와 유사한 동작을 수행</p><ul><li>두 컨트랙트가 서로 호출시, 네트워크를 통해 메시지를 보내고 비동기적으로 처리</li><li>즉, 어떤 컨트랙트 메소드 호출시 트랜잭션이 종료된 후 미래 블록에서 호출이 처리되는 것을 의미</li><li>atomic 하지 않으므로 수동으로 롤백</li></ul><h3>컨트랙트 간 데이터 읽기</h3><ul><li>이더리움 호출방식이 동기 방식이므로 다른 컨트랙트의 데이터를 바로 읽을 수 있음</li><li>TON은 비동기 방식이므로, 즉시 값을 얻을 순 없음</li><li>getter 메서드가 있는데 컨트랙트가 아닌 off-chain 클라이언트에서만 호출 가능</li></ul><h3>스마트 컨트랙트 코드의 변경 가능성</h3><ul><li>이더리움은 프록시 패턴으로 업그레이드를 해야함</li><li>TON은 컨트랙트가 code variable 영역에 작성되면 업그레이드가 가능하고, 그렇지 않은 경우 불변함</li></ul><h3>데이터 구조의 제한</h3><p>이더리움에서는 맵과 같은 무한히 커질 수 있는 데이터 구조에 대해 고정된 가스 비용을 부과하여 스팸 공격을 방지</p><ul><li>사용자가 새로운 상태 데이터를 쓸 때 그에 따른 비용을 지불하기 때문에, 공격자는 높은 비용을 감수해야 하며, 다른 사용자는 피해를 보지 않음</li></ul><p>반면, TON에서는 데이터 구조의 크기에 따라 쓰기 비용이 비례하여 증가</p><ul><li>이로 인해 무한 데이터 구조가 스팸 공격에 취약할 수 있음</li><li>따라서, TON에서는 컨트랙트를 샤딩하여 데이터를 여러 하위 계약으로 분할하는 것이 중요</li><li>이는 무한히 많은 사용자 잔액이나 NFT 항목을 처리할 때 효과적입니다.</li></ul><p>이러한 차이점은 TON이 “Bag of Cells” 아키텍처를 사용하기 때문</p><ul><li>TON 블록체인의 “Bag of Cells” 아키텍처는 컨트랙트 상태를 1023비트 크기의 셀로 나눔</li><li>이 셀들은 트리 구조로 연결되며, 맵(Map)과 같은 데이터 구조는 이 트리 구조 내에서 구현</li><li>데이터가 많아지면 트리의 높이가 증가하고, 특정 데이터를 업데이트할 때 트리의 전체 높이에 걸쳐 새로운 해시를 작성</li><li>이로 인해 데이터 구조가 커질수록 쓰기 비용이 증가하게 되며, 스팸 공격에 취약</li></ul><p>이러한 구조적 특성 때문에 이더리움처럼 고정된 가스비로는 처리할 수 없는 문제가 발생하며, 이로 인해 무한 데이터 구조를 피하는 것이 권장</p><ul><li>대신 컨트랙트를 샤딩에 의존</li><li>예를 들어 USDC 컨트랙트에 잠재적으로 무한한 수의 사용자 잔액이 있는 경우, 단일 계약을 여러 개의 하위 계약으로 분할하여 각 하위 계약이 단일 사용자의 잔액을 보유</li></ul><h3>지갑 시스템</h3><p>TON에서 지갑은 배포해야 하는 컨트랙트</p><ul><li>사용자는 여러 지갑을 배포할 수 있음</li><li>지갑 주소는 컨트랙트 코드와 초기화 변수로 결정 (ex. public key, sequence number)</li><li>즉, 사용자가 지갑 주소를 알려면 초기화 변수를 알아야 함</li><li>트랜잭션은 지갑 컨트랙트를 거쳐 dapp 컨트랙트로 전송</li></ul><h3>Reference</h3><ol><li><a href="https://blog.ton.org/six-unique-aspects-of-ton-blockchain-that-will-surprise-solidity-developers">https://blog.ton.org/six-unique-aspects-of-ton-blockchain-that-will-surprise-solidity-developers</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5dce3b75036c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TON Cell & Bag of Cells(BoC)]]></title>
            <link>https://medium.com/@voidgun93/ton-cell-bag-of-cells-boc-35353e547902?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/35353e547902</guid>
            <category><![CDATA[ton]]></category>
            <category><![CDATA[toncoin]]></category>
            <category><![CDATA[boc]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Wed, 28 Aug 2024 03:55:14 GMT</pubDate>
            <atom:updated>2024-08-28T03:55:14.678Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cell</h3><ul><li>1023 bits까지 저장가능하며, 최대 4개의 다른 셀을 참조 가능</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/0*7Hw6B3nIRuUCZIKD" /></figure><h3>Bag of Cells</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/0*EpgYsoatt8q33kRa" /></figure><ul><li>BoC는 Cell들을 바이트 배열로 직렬화한 포맷</li><li>TON에서는 모든 객체가 셀로 구성되어 있음</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/0*ngiKP8I2I-C39kTo" /></figure><h3>Cell Serialization</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/0*bG4VMZ7aqE7hVtk1" /></figure><pre>1[8_] -&gt; {<br>  24[0AAAAA],<br>  7[FE] -&gt; {<br>    24[0AAAAA]<br>  }<br>}</pre><ul><li>1비트 크기의 루트 cell을 가지고 있고, 이는 두개의 cell에 연결되어 있음</li><li>하나는 24비트의 크기를 가지는 cell, 다른 하나는 7 비트 크기의 셀을 가르킴</li><li>7비트의 셀은 24비트의 크기를 가지는 셀을 포함함</li></ul><h4>Cell Serialization</h4><pre>1[8_]<br>24[0AAAAA]<br>7[FE] </pre><p>먼저, Cell 직렬화를 위해서 중복된 셀을 제거하고, 위와 같이 표현합니다. 다음으로, Cell의 정렬을 아래와 같이 수행합니다. 루트 셀이 맨 위에 있고, 이를 index 0으로 설정합니다. 중간 셀은 중간에 위치하고, index 1로 설정합니다. 리프 셀은 마지막에 위치하고 index 2로 설정합니다. 즉, 어떤 셀이 가르키고 있다면, 가르키고 있는 셀 뒤에 위치해야합니다.</p><pre>1[8_]      -&gt; index 0 (root cell)<br>7[FE]      -&gt; index 1<br>24[0AAAAA] -&gt; index 2</pre><p>다음으로, refs descriptor와 bits descriptor를 계산해야합니다. 계산 과정은 아래와 같습니다.</p><ul><li>첫 번째 바이트(참조 디스크립터)는 r + 8s + 32l로 계산됩니다. 여기서 r은 셀 참조(링크)의 수를 나타내며, 0 ≤ r ≤ 4입니다. s는 일반 셀일 경우 0, exotic 셀일 경우 1입니다. l은 셀의 레벨로 0 ≤ l ≤ 3입니다. 일반 셀의 경우, 참조하는 모든 셀들의 레벨 중 가장 높은 값과 동일합니다.</li><li>두 번째 바이트(비트 디스크립터)는 floor(b / 8) + ceil(b / 8)로 계산되며, 여기서 b는 셀에 있는 비트의 수로, 0 ≤ b ≤ 1023입니다. 이 디스크립터는 셀 데이터의 전체 4비트 그룹의 길이를 나타내며, 비어 있지 않다면 최소 1로 설정됩니다.</li></ul><p>위의 방식에 따라 디스크립터를 계산하면 아래와 같습니다. 1[8_]의 경우 cell reference 수가 2이고, exotic cell이 아니므로, s는 0입니다. 이때 모든 셀의 레벨은 0입니다. 왜냐하면, [0AAAAA]는 다른 셀을 참조하지 않으므로 0이고, 이를 참조하는 [FE] 셀의 레벨도 0으로 결정됩니다. 마찬가지로, 이를 참조하는 [8_] 셀 역시 레벨이 0으로 결정됩니다. 따라서, [8_]의 참조 디스크립터는 2입니다.</p><p>같은 방식으로 [FE]의 참조 디스크립터를 계산하면, 1+8*0+32*0이므로, 1입니다. [0AAAAA]는 0+8*0+32*0이므로 0입니다. 다음으로, 비트 디스크립터를 계산해보겠습니다. 각각의 셀의 비트의 수는 1, 7, 24 이므로, floor(b / 8) + ceil(b / 8)를 계산하면, 1, 1, 6이 결과 값으로 나타납니다.</p><pre>1[8_]      -&gt; 0201 -&gt; 2 refs, length 1<br>7[FE]      -&gt; 0101 -&gt; 1 ref, length 1<br>24[0AAAAA] -&gt; 0006 -&gt; 0 refs, length 6</pre><p>다음으로, 8bits 단위로 데이터를 맞추는 작업을 수행합니다. 부족하면, 0과 1로 비트를 채워넣습니다. 결과는 아래와 같습니다. 불완전한 비트 그룹이라면 1을 뒤에 채워 넣습니다. 1비트, 7비트는 불완전한 비트 그룹이므로, 1을 패딩합니다.</p><pre>1[8_]      -&gt; C0     -&gt; 0b10000000-&gt;0b11000000<br>7[FE]      -&gt; FF     -&gt; 0b11111110-&gt;0b11111111<br>24[0AAAAA] -&gt; 0AAAAA -&gt; do not change (full groups)</pre><p>그러고나서, 참조 인덱스를 아래와 같이 추가합니다. 0201인 이유는 2개의 셀을 참조하고 있고, 참조하고 있는 셀의 인덱스는 1이라는 뜻입니다. 02는 인덱스 2를 한개 참조하고 있음을 의미합니다.</p><pre>0 1[8_]      -&gt; 0201 -&gt; refers to 2 cells with such indexes<br>1 7[FE]      -&gt; 02 -&gt; refers to cells with index 2<br>2 24[0AAAAA] -&gt; no refs</pre><p>이를 한꺼번에 표현하면 아래와 같습니다. 그리고 이를 순서대로 붙이면, 14 바이트 크기를 가지는 배열 0201c002010101ff0200060aaaaa을 얻을 수 있습니다.</p><pre>0201 C0     0201  <br>0101 FF     02<br>0006 0AAAAA </pre><h4>Packing BoC</h4><pre>b5ee9c72                      -&gt; id tl-b of the BoC structure<br>01                            -&gt; flags and size:(## 3), in our case the flags are all 0,<br>                                 and the number of bytes needed to store the number of cells is 1.<br>                                 we get - 0b0_0_0_00_001<br>01                            -&gt; number of bytes to store the size of the serialized cells<br>03                            -&gt; number of cells, 1 byte (defined by 3 bits size:(## 3), equal to 3.<br>01                            -&gt; number of root cells - 1<br>00                            -&gt; absent, always 0 (in current implementations)<br>0e                            -&gt; size of serialized cells, 1 byte (size defined above), equal to 14<br>00                            -&gt; root cell index, size 1 (determined by 3 size:(## 3) bits from header),<br>                                 always 0<br>0201c002010101ff0200060aaaaa  -&gt; serialized cells</pre><p>위에서 얻은 직렬화된 셀을 위의 규칙에 따라서 패킹해줍니다 [1]. 패킹된 결과는 다음과 같습니다. b5ee9c7201010301000e000201c002010101ff0200060aaaaa</p><p>Serialization [2], Deserialization [3] 구현체는 다음의 링크를 참조하시길 바라겠습니다.</p><h3>Reference</h3><ol><li><a href="https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/tl/boc.tlb#L25">https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/tl/boc.tlb#L25</a></li><li><a href="https://github.com/xssnick/tonutils-go/blob/master/tvm/cell/serialize.go">https://github.com/xssnick/tonutils-go/blob/master/tvm/cell/serialize.go</a></li><li><a href="https://github.com/xssnick/tonutils-go/blob/master/tvm/cell/parse.go">https://github.com/xssnick/tonutils-go/blob/master/tvm/cell/parse.go</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35353e547902" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TON의 주소 체계와 특징]]></title>
            <link>https://medium.com/@voidgun93/ton%EC%9D%98-%EC%A3%BC%EC%86%8C-%EC%B2%B4%EA%B3%84%EC%99%80-%ED%8A%B9%EC%A7%95-49c2f167437a?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/49c2f167437a</guid>
            <category><![CDATA[toncoin]]></category>
            <category><![CDATA[telegram]]></category>
            <category><![CDATA[ton]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Wed, 28 Aug 2024 03:54:39 GMT</pubDate>
            <atom:updated>2024-08-28T03:54:39.535Z</atom:updated>
            <content:encoded><![CDATA[<h3>1. TON의 주소 표현 방식</h3><ul><li>HEX: 개발자와 고급 사용자를 위한 형식</li><li>Bounceable: 일반적으로 사용되는 주소 형식</li><li>Non-bounceable: 특수한 경우에 사용되는 주소 형식</li></ul><h3>2. Bounceable 주소의 개념</h3><p>컨트랙트 호출 실패 시 콜백을 받을 수 있는 주소 형식입니다. 실패 시 보낸 금액을 환불받을 수 있습니다(수수료 제외).</p><h3>3. TON의 스마트 컨트랙트 지갑</h3><p>TON에서 모든 지갑은 스마트 컨트랙트입니다. 따라서 지갑에 돈을 보내는 것은 스마트 컨트랙트를 호출하는 것과 같습니다.</p><h3>4. 지갑 동작의 특징</h3><ul><li>상대방 지갑이 이미 배포된 경우: 사용자가 지정한 bounceable/non-bounceable 설정을 존중</li><li>상대방 지갑이 아직 배포되지 않은 경우: 항상 non-bounceable 모드로 TON 송금</li></ul><h3>5. 주소 인코딩</h3><p>TON 주소는 workchain ID와 workchain 내 주소로 구성됩니다. 현재는 마스터체인(-1)과 기본 워크체인(0)만 사용 중이며, 둘 다 256비트 주소를 사용합니다.</p><h3>6. 사용자 친화적 주소 형식</h3><p>이 형식은 태그 바이트, workchain ID, 스마트 컨트랙트 주소, CRC16-CCITT 체크섬으로 구성되며, base64 또는 base64url로 인코딩됩니다.</p><h3>7. TON과 이더리움의 차이점</h3><ul><li>컨트랙트 유지 비용: TON에서는 컨트랙트가 ‘임대료’를 지불해야 합니다.</li><li>컨트랙트 간 호출: TON은 비동기식, 이더리움은 동기식입니다.</li><li>컨트랙트 코드 수정: TON에서는 쉽게 수정 가능합니다.</li><li>데이터 구조: TON은 무제한 데이터 구조를 피해야 합니다.</li><li>지갑과 공개키 관계: TON에서는 하나의 공개키로 여러 지갑을 배포할 수 있습니다.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49c2f167437a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TON 컨셉]]></title>
            <link>https://medium.com/@voidgun93/ton-%EC%BB%A8%EC%85%89-4bb49e6d1e45?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/4bb49e6d1e45</guid>
            <category><![CDATA[ton]]></category>
            <category><![CDATA[toncoin]]></category>
            <category><![CDATA[telegram]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Wed, 28 Aug 2024 03:54:12 GMT</pubDate>
            <atom:updated>2024-08-28T07:40:19.436Z</atom:updated>
            <content:encoded><![CDATA[<h3>1. Single Actor = Contract</h3><p>TON에서 Single Actor는 Contract와 동일한 개념입니다. 이는 다음과 같은 특징을 가집니다:</p><ul><li>행위와 저장공간을 갖는 엔티티</li><li>주소, 코드, 데이터, 잔고 등의 속성 보유</li><li>트랜잭션을 통해 행위 수행 (메시지 수신, 이벤트 처리, 속성 변경, 응답 생성 등)</li></ul><h3>2. Account Chain</h3><p>Account Chain은 특정 계정의 연속적인 트랜잭션 흐름을 나타냅니다:</p><ul><li>Tx1 -&gt; Tx2 -&gt; Tx3 형태로 연결</li><li>각 트랜잭션은 하나의 이전 트랜잭션과 최대 하나의 다음 트랜잭션을 가짐</li><li>트랜잭션들은 블록으로 그룹화될 수 있음</li><li>[Tx1 -&gt; Tx2] -&gt; [Tx3 -&gt; Tx4 -&gt; Tx5] -&gt; [] -&gt; [Tx6]</li></ul><h3>3. ShardChain</h3><p>ShardChain은 여러 AccountChain의 집합으로, 다음과 같은 특징을 가집니다:</p><ul><li>동적 분할 및 병합 가능: 하나의 샤드체인에 100만개 이상의 계정이 존재하고, 너무 많은 tx가 발생하면 분할, 반대로 너무 적은 처리를 하고 있으면, 더 큰 샤드로 병함</li><li>샤드 prefix로 구분 (예: 0b00101): 같은 prefix를 가지면 모드 같은 샤드 체인</li><li>계정 간 메시지 교환 가능 (순서 보장)</li></ul><h3>4. TON 블록체인의 구조</h3><p>TON은 여러 블록체인이 동시에 작동할 수 있는 구조를 가집니다:</p><ul><li>블록체인 간 상호작용은 메시지를 통해 이루어짐</li><li>Workchain과 MasterChain으로 구성</li></ul><h4>4.1 Workchain</h4><p>Workchain의 주요 특징:</p><ul><li>샤드체인 그룹의 규칙을 정의할 수 있는 블록체인</li><li>Solidity 스마트 컨트랙트를 실행할 수 있는 워크체인을 생성 가능</li><li>모든 참여자가 워크체인을 생성할 수 있지만, 비용이 많이 들고, 2/3이상의 밸리데이터 투표를 받아야함</li><li>최대 2³²개 생성 가능, 각 워크체인은 2⁶⁰개의 샤드로 분리 가능</li><li>현재는 MasterChain과 BaseChain 두 개만 존재</li></ul><h4>4.2 MasterChain</h4><p>MasterChain의 역할:</p><ul><li>메시지 라우팅과 트랜잭션 실행의 동기화 담당</li><li>모든 체인의 최근 블록 해시를 보유하여 전체 상태 파악 가능</li><li>마스터 체인은 다른 모든 체인의 가장 최근 블록 해시를 알고 있으므로, 모든 멀티체인의 상태를 명확히 알 수 있음</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4bb49e6d1e45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pendle Finance — #5 SY, PT Swap]]></title>
            <link>https://medium.com/@voidgun93/pendle-finance-5-sy-pt-swap-037154d479dc?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/037154d479dc</guid>
            <category><![CDATA[defi]]></category>
            <category><![CDATA[pendle-finance]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[yield-farming]]></category>
            <category><![CDATA[derivatives]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Mon, 03 Jun 2024 08:17:12 GMT</pubDate>
            <atom:updated>2024-06-04T00:31:16.910Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pendle Finance — #5 SY, PT Swap</h3><h3>Intro</h3><p>이번 글에서는 Market을 구성하는 두개의 토큰, SY, PT Pool에서 각 토큰간의 스왑을 분석해보고자 한다. 보통의 DeFi 프로토콜에서의 스왑에서 중요한 점은 Pool의 토큰 수량에 기반해서 내가 받을 토큰이 정확히 계산되어야 한다. 하지만, Pendle의 경우에는 토큰의 가치는 Pool의 토큰 수량 뿐만 아니라, 토큰의 이자율 그리고 만기일도 고려해야한다. 토큰의 가치는 토큰의 이자율과 만기일에 따라 결정되기 때문이다. 따라서, 이번 글에서는 토큰의 이자율과 만기일이 스왑에 어떻게 반영되는지 파악하고자 한다.</p><h3>SY &lt;-&gt; PT</h3><p>SY와 PT의 토큰간 스왑에서 가장 중요한 것은 내가 스왑하고자 하는 토큰과 받을 토큰의 양이 정확하게 계산되는 것이다. 내가 받을 토큰의 양은 MarketMathCore.sol와 MarketApproxLib.sol에서 라이브러리로 지원한다. 내가 받을 토큰의 양이 정확하게 계산이 되었다면, 계산된 결과 값을 바탕으로 토큰을 전송하고 받기만 하면 된다. 따라서, 이번 절에서는 SY와 PT 간 스왑이 발생할때, 받을 토큰의 양을 어떻게 계산하는지에 대해 다뤄보고자 한다.</p><h4>SY-&gt;PT (swapExactSyForPt)</h4><pre>struct ApproxParams {<br>    uint256 guessMin;<br>    uint256 guessMax;<br>    uint256 guessOffchain; // pass 0 in to skip this variable<br>    uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2<br>    uint256 eps; // the max eps between the returned result &amp; the correct result, base 1e18. Normally this number will be set<br>    // to 1e15 (1e18/1000 = 0.1%)<br>}<br><br>function _swapExactSyForPt(<br>        address receiver,<br>        address market,<br>        uint256 exactSyIn,<br>        uint256 minPtOut,<br>        ApproxParams calldata guessPtOut,<br>        LimitOrderData calldata limit<br>    ) internal returns (uint256 netPtOut, uint256 netSyFee) {<br>        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();<br>        uint256 netSyLeft = exactSyIn;<br>        bool doMarketOrder = true;<br><br>        if (!_isEmptyLimit(limit)) {<br>            (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);<br>            if (doMarketOrder) {<br>                _transferOut(address(SY), market, netSyLeft);<br>            }<br>        }<br><br>        if (doMarketOrder) {<br>            (uint256 netPtOutMarket, ) = _readMarket(market).approxSwapExactSyForPt(<br>                YT.newIndex(),<br>                netSyLeft,<br>                block.timestamp,<br>                guessPtOut<br>            );<br><br>            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);<br><br>            netPtOut += netPtOutMarket;<br>            netSyFee += netSyFeeMarket;<br>        }<br><br>        if (netPtOut &lt; minPtOut) revert(&quot;Slippage: INSUFFICIENT_PT_OUT&quot;);<br>    }</pre><p>위의 함수는 보유하고 있는 SY의 토큰 수량을 PT로 스왑하는 함수이다. approxSwapExactSyForPt함수에서 사용자가 입력한 SY의 수량, YT의 exchange rate, 현재의 블록 타임스탬프, 유추 값을 바탕으로 사용자가 받을 PT의 값을 계산한다.</p><pre>function approxSwapExactSyForPt(<br>        MarketState memory market,<br>        PYIndex index,<br>        uint256 exactSyIn,<br>        uint256 blockTime,<br>        ApproxParams memory approx<br>    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/) {<br>        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);<br>        if (approx.guessOffchain == 0) {<br>            // no limit on min<br>            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));<br>            validateApprox(approx);<br>        }<br><br>        for (uint256 iter = 0; iter &lt; approx.maxIteration; ++iter) {<br>            uint256 guess = nextGuess(approx, iter);<br><br>            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);<br><br>            if (netSyIn &lt;= exactSyIn) {<br>                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {<br>                    return (guess, netSyFee);<br>                }<br>                approx.guessMin = guess;<br>            } else {<br>                approx.guessMax = guess - 1;<br>            }<br>        }<br><br>        revert(&quot;Slippage: APPROX_EXHAUSTED&quot;);<br>    }<br><br>function getMarketPreCompute(<br>        MarketState memory market,<br>        PYIndex index,<br>        uint256 blockTime<br>    ) internal pure returns (MarketPreCompute memory res) {<br>        if (MiniHelpers.isExpired(market.expiry, blockTime)) revert Errors.MarketExpired();<br><br>        uint256 timeToExpiry = market.expiry - blockTime;<br><br>        res.rateScalar = _getRateScalar(market, timeToExpiry);<br>        res.totalAsset = index.syToAsset(market.totalSy);<br><br>        if (market.totalPt == 0 || res.totalAsset == 0)<br>            revert Errors.MarketZeroTotalPtOrTotalAsset(market.totalPt, res.totalAsset);<br><br>        res.rateAnchor = _getRateAnchor(<br>            market.totalPt,<br>            market.lastLnImpliedRate,<br>            res.totalAsset,<br>            res.rateScalar,<br>            timeToExpiry<br>        );<br>        res.feeRate = _getExchangeRateFromImpliedRate(market.lnFeeRateRoot, timeToExpiry);<br>    }<br><br>function nextGuess(ApproxParams memory approx, uint256 iter) internal pure returns (uint256) {<br>        if (iter == 0 &amp;&amp; approx.guessOffchain != 0) return approx.guessOffchain;<br>        if (approx.guessMin &lt;= approx.guessMax) return (approx.guessMin + approx.guessMax) / 2;<br>        revert(&quot;Slippage: guessMin &gt; guessMax&quot;);<br>    }</pre><p>입력한 SY 토큰에 수량에 대응하는 PT 토큰의 수량은 이진 탐색을 사용하여, 계산한다. 먼저, getMarketPreCompute를 호출하여 rateScalar, totalAsset, rateAnchor, feeRate을 계산한다. 각 변수는 아래의 의미를 가진다.</p><ul><li>rateScalar: scalarRoot(초기 설정값)*365Day/timeToExpiry로 계산되며, 시장의 변동성을 반영하고, 시간이 지남에 따라 교환비율을 조절하는 역할을 수행. 시간이 지남에 따라 증가한다.</li><li>totalAsset: Pool의 totalSY를 현재의 교환비율을 곱한 값이다. 이는 SY 토큰이 실제로 자산으로 변환될 때 얼마만큼의 가치를 가지는지 보기위함이다.</li></ul><pre>function syToAsset(uint256 exchangeRate, uint256 syAmount) internal pure returns (uint256) {<br>        return (syAmount * exchangeRate) / ONE;<br>    }</pre><ul><li>rateAnchor: 시장에서의 자산 비율의 변화와 금리 변화를 반영하며, exchange rate을 조정하는 역할을 수행한다. 수식은 아래와 같다.</li></ul><pre>newExchangeRate = e^((lastLnImpliedRate*timeToExpiry)/365 DAYS)<br>rateAnchor = newExchangeRate -ln(totalPt/(totalPt+totalAsset))/rateScalar</pre><p>위에서 계산된 rateScalar, totalAsset, rateAnchor을 바탕으로 _getExchangeRate을 호출하여, 교환비율을 계산한다. 교환비율은 아래와 같이 계산된다.</p><pre>numerator = totalPt - netPtToAccount<br>proportion = numerator/(totalPt+totalAsset)<br>exchangeRate = ln(proportion)/rateScalar + rateAnchor</pre><p>다음으로, 현재 받을 PT의 추정값인 guess와 추정값을 기반으로 계산된 SY 토큰의 양이 사용자가 스왑하고자 하는 SY 토큰의 수량이 오차범위 내에 있는지 확인한다. 아래는 위의 과정을 단계별로 정리한 것이다.</p><ol><li>현재 추정값(guess) 계산:nextGuess 함수를 호출하여 찾고자 하는 값 범위의 중간 값을 반환한다.</li><li>추정값 기반 SY 토큰 양 계산: guess 값과 현재 시장 상태를 고려하여 받을 SY 토큰의 값을 calcSyIn을 호출하여 계산한다.</li><li>오차 범위 확인: 계산된 SY 토큰의 수량이 오차범위 내에 들어왔는지 확인한다.</li><li>이진탐색 반복: 오차범위내에 있지 않는다면, 범위를 수정하여 1번에서 3번의 과정을 반복한다.</li></ol><p>이진 탐색을 통해 받을 PT의 값이 계산되었다면, Market의 swapSyForExactPt를 호출하여, 스왑을 진행한다.</p><pre>//PendleMarketV3.sol<br>function swapSyForExactPt(<br>        address receiver,<br>        uint256 exactPtOut,<br>        bytes calldata data<br>    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {<br>        MarketState memory market = readState(msg.sender);<br><br>        uint256 netSyToReserve;<br>        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);<br><br>        if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);<br>        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);<br><br>        _writeState(market);<br><br>        if (data.length &gt; 0) {<br>            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netSyIn.neg(), data);<br>        }<br><br>        // have received enough SY<br>        if (_selfBalance(SY) &lt; market.totalSy.Uint())<br>            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());<br><br>        emit Swap(msg.sender, receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);<br>    }</pre><p>Market의 swapSyForExactPt의 핵심은 market.swapSyForExactPt이다. 이는 이전에 계산된 PT의 수량과 수수료롤 고려하여 이에 맞는 SY를 다시 계산하여, 계산된 SY 값으로 실제 스왑을 진행한다.</p><h4>PT-&gt;SY (swapExactPtForSy)</h4><pre>function swapExactPtForSy(<br>        address receiver,<br>        uint256 exactPtIn,<br>        bytes calldata data<br>    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {<br>        MarketState memory market = readState(msg.sender);<br><br>        uint256 netSyToReserve;<br>        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);<br><br>        if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);<br>        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);<br><br>        _writeState(market);<br><br>        if (data.length &gt; 0) {<br>            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);<br>        }<br><br>        if (_selfBalance(PT) &lt; market.totalPt.Uint())<br>            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());<br><br>        emit Swap(msg.sender, receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);<br>    }</pre><p>PT에서 SY로 스왑할때는 입력한 PT의 양에 대응하는 SY의 양을 market.swapExactPtForSy을 통해서 계산하고 스왑한다. 입력한 PT의 양에 대응하는 SY의 값을 계산하는 것은 SY에서 PT로 스왑하는 것과 마찬가지로, rateScalar, totalAsset, rateAnchor를 구한 후 이를 바탕으로 새로운 교환비율을 도출하여 계산한다.</p><p>다만, PT에서 SY 스왑할때는 이진탐색을 사용하여, 추정값을 계산하지 않는다. 그 이유로는 Market의 구현체를 보면 알 수 있다. Market의 구현체에는 swapExactPtForSy와 swapSyForExactPt가 구현되어 있다. Market에서 SY를 PT로 스왑할때에는 정확한 Pt의 수량을 입력해야함을 요구하고 있다. 이를 위해서, 이진탐색을 통해 정확한 Pt의 수량을 먼저 찾았다. 반면에, PT에서 SY로 스왑할때는 정확한 PT값이 입력되므로, 이진탐색을 사용하여 스왑될 양을 미리 계산할 필요가 없는 것으로 보인다.</p><h3>Conclusion</h3><p>이번 글에서는 SY와 PT의 교환과 만기일과 교환비율이 교환에 어떤 영향을 미치는 지에 대해서 다루어보았다. 여기에서 의문이 들수 있는 지점은 풀에는 SY와 PT만 존재하는데, YT 토큰은 어떻게 교환하는지 의문이 들수 있다. 따라서, 다음 글에서는 풀에서의 YT 토큰의 교환에 대해서 다루어보고자 한다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=037154d479dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pendle Finance — #4 PY Token Mint/Redeem with Router]]></title>
            <link>https://medium.com/@voidgun93/pendle-finance-4-py-token-mint-redeem-with-router-0b3ff780302b?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b3ff780302b</guid>
            <category><![CDATA[derivatives]]></category>
            <category><![CDATA[yield-farming]]></category>
            <category><![CDATA[pendle-finance]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[defi]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Mon, 27 May 2024 01:04:34 GMT</pubDate>
            <atom:updated>2024-05-27T01:04:34.676Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pendle Finance — #4 PY Token Mint/Redeem with Router</h3><h3>Intro</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*teP3uQDXUjc50VBEQ7366A.png" /></figure><p>이번 글에서는 Pendle 라우터를 사용하여, 어떻게 PY 토큰(PT + YT)의 발행과 상환에 대해서 다루도록 하겠다. 이를 더 잘 이해하기 위해 이전 글인 SY 토큰의 발행이 어떻게 이루어지는지 보고 오는 것을 추천한다. 라우터를 사용하여 PY 토큰을 발행하는 함수는 보유하고 있는 SY 토큰을 기반으로 PY 토큰을 발행하는데, SY 토큰을 보유하고 있지 않은 경우에는 기초자산을 SY 토큰으로 변환 후 PY 토큰을 발행한다. 따라서, 이번 글에서는 보유하고 있는 SY 토큰을 기반으로 YT 토큰을 발행하는 프로세스에 대해서 다루기 때문에 이전 글을 보고 오는 것을 다시 한번 추천한다.</p><ul><li><a href="https://medium.com/@voidgun93/pendle-finance-3-sy-token-mint-redeem-with-router-145f39c82786">Pendle Finance — #3 SY Token Mint/Redeem with Router</a></li></ul><h3>PY Token Mint &amp; Redeem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*lgo4GIfVRv8ikdfi09Jr2w.png" /></figure><pre>function _mintPyFromSy(<br>        address receiver,<br>        address SY,<br>        address YT,<br>        uint256 netSyIn,<br>        uint256 minPyOut,<br>        bool doPull<br>    ) internal returns (uint256 netPyOut) {<br>        if (doPull) {<br>            _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);<br>        }<br><br>        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);<br>        if (netPyOut &lt; minPyOut) revert(&quot;Slippage: INSUFFICIENT_PT_YT_OUT&quot;);<br>    }</pre><pre><br>//PendleYieldTokenV2<br>function _mintPY(<br>        address[] memory receiverPTs,<br>        address[] memory receiverYTs,<br>        uint256[] memory amountSyToMints<br>    ) internal returns (uint256[] memory amountPYOuts) {<br>        amountPYOuts = new uint256[](amountSyToMints.length);<br><br>        uint256 index = _pyIndexCurrent();<br><br>        for (uint256 i = 0; i &lt; amountSyToMints.length; i++) {<br>            amountPYOuts[i] = _calcPYToMint(amountSyToMints[i], index);<br><br>            _mint(receiverYTs[i], amountPYOuts[i]);<br>            IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);<br><br>            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);<br>        }<br>    }</pre><p>PY 토큰의 발행은 상당히 간결하다. 라우터에서 mintPyFromSy를 호출하면, 보유하고 있는 SY 토큰을 YT 토큰 컨트랙트에 예치후 Yield Token Contract의 mintPY를 호출한다. mintPY는 SY 토큰으로부터 교환비율을 가져와 발행할 PY 토큰을 계산하고, 같은 수량의 PT 토큰과 YT 토큰을 발행한다 [1].</p><pre>function _redeemPyToSy(<br>        address receiver,<br>        address YT,<br>        uint256 netPyIn,<br>        uint256 minSyOut<br>    ) internal returns (uint256 netSyOut) {<br>        address PT = IPYieldToken(YT).PT();<br><br>        _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);<br><br>        bool needToBurnYt = (!IPYieldToken(YT).isExpired());<br>        if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);<br><br>        netSyOut = IPYieldToken(YT).redeemPY(receiver);<br>        if (netSyOut &lt; minSyOut) revert(&quot;Slippage: INSUFFICIENT_SY_OUT&quot;);<br>    }</pre><p>사용자는 라우터의 redeemPyToSy를 호출하여, SY를 수령할 수 있다. 보유하고 있는 PT 토큰을 YT 토큰으로 전송하고, 만기일을 확인한다. 만기일이 지난 경우에는 YT 토큰을 가져오지 않고, 만기일이 지나지 않은 경우에는 같은 양의 YT토큰을 보유하고 있어야한다. 만기일이 지난 YT 토큰은 가치가 없으므로, 소각을 하지 않는 것으로 볼 수 있다.</p><pre>function _redeemPY(<br>        address[] memory receivers,<br>        uint256[] memory amountPYToRedeems<br>    ) internal returns (uint256[] memory amountSyOuts) {<br>        uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();<br>        IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);<br>        if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);<br><br>        uint256 index = _pyIndexCurrent();<br>        uint256 totalSyInterestPostExpiry;<br>        amountSyOuts = new uint256[](receivers.length);<br><br>        for (uint256 i = 0; i &lt; receivers.length; i++) {<br>            uint256 syInterestPostExpiry;<br>            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);<br>            _transferOut(SY, receivers[i], amountSyOuts[i]);<br>            totalSyInterestPostExpiry += syInterestPostExpiry;<br><br>            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountSyOuts[i]);<br>        }<br><br>        address treasury = IPYieldContractFactory(factory).treasury();<br>        _transferOut(SY, treasury, totalSyInterestPostExpiry);<br>    }<br><br>function _calcSyRedeemableFromPY(<br>        uint256 amountPY,<br>        uint256 indexCurrent<br>    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {<br>        syToUser = SYUtils.assetToSy(indexCurrent, amountPY);<br>        if (isExpired()) {<br>            uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);<br>            syInterestPostExpiry = totalSyRedeemable - syToUser;<br>        }<br>    }</pre><p>다음으로, YT 컨트랙트의 redeemPy를 호출한다. 이때 중요하게 봐야할 것이 firstPYIndex와 index의 차이이다. index는 토큰의 만기 이전에 발생하는 거래에 대한 교환비율이고, firstPYIndex는 만기 시점의 교환비율이다. 주요 차이점은 아래와 같다.</p><ul><li>타이밍: index는 토큰의 만기일 동안 지속적으로 업데이트되며, firstPYIndex는 만기 시점에 한번만 설정</li><li>기능: index는 만기 이전의 지속적인 수익 계산에 사용되며, firstPYIndex는 만기 이후의 수익 계산에 사용되어 고정된 기준점 제공</li></ul><p>즉, 만기일이 지난 <strong>PY 토큰을 상환시 </strong><strong>firstPYIndex와 </strong><strong>index의 차이가 수수료로 지급</strong>됨을 알 수 있다.</p><h3>Reference</h3><ol><li><a href="https://medium.com/@voidgun93/pendle-finance-2-sy-token-yield-contract-implementation-6f2f8beeb7a1">https://medium.com/@voidgun93/pendle-finance-2-sy-token-yield-contract-implementation-6f2f8beeb7a1</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b3ff780302b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pendle Finance — #3 SY Token Mint/Redeem with Router]]></title>
            <link>https://medium.com/@voidgun93/pendle-finance-3-sy-token-mint-redeem-with-router-145f39c82786?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/145f39c82786</guid>
            <category><![CDATA[yield-farming]]></category>
            <category><![CDATA[defi]]></category>
            <category><![CDATA[derivatives]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[pendle-finance]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Thu, 23 May 2024 08:54:45 GMT</pubDate>
            <atom:updated>2024-05-24T01:43:47.333Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pendle Finance — #3 SY Token Mint/Redeem with Router</h3><h3>Intro</h3><p>이번 글에서는 SY Token의 발행과 상환이 실제로 어떤 프로세스로 이루어지는지 다루도록 하겠다.</p><h3>Backgrounds</h3><h4>Pendle Router [1]</h4><p>Pendle Router(이하 Router)는 Pendle 시스템에서 다양한 SY, PT, YT 및 Market과의 상호작용을 보다 쉽게 하는 컨트랙트로, 유니스왑의 Router와 그 성격이 유사하다. 유동성 추가/제거, 토큰의 스왑(PT -&gt; YT, YT-&gt;PT), 만기가 지난 PT의 상환을 지원한다. 또한, 최적의 가스의 효율을 위해 오프체인 데이터를 사용하며, 여러 DEX와 통합되고 Limit Order를 지원한다.</p><p>구체적으로 사용자는 IPActionMiscV3 [2]에 정의된 인터페이스를 이용하여, SY, PY 토큰을 발행, 상환을 요청할 수 있다. 또한, IPActionSwapPTV3 [3], IPActionSwapYTV3 [4]의 인터페이스를 이용하여, PT, YT, SY 토큰간 교환도 가능하게 한다.</p><h3>SY Token Mint &amp; Redeem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*MMOncqCpSdVgVLH9TBb-GQ.png" /></figure><pre>enum SwapType {<br>    NONE,<br>    KYBERSWAP,<br>    ONE_INCH,<br>    // ETH_WETH not used in Aggregator<br>    ETH_WETH<br>}<br><br>function _mintSyFromToken(<br>        address receiver,<br>        address SY,<br>        uint256 minSyOut,<br>        TokenInput calldata inp<br>    ) internal returns (uint256 netSyOut) {<br>        SwapType swapType = inp.swapData.swapType;<br><br>        uint256 netTokenMintSy;<br><br>        if (swapType == SwapType.NONE) {<br>            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);<br>            netTokenMintSy = inp.netTokenIn;<br>        } else if (swapType == SwapType.ETH_WETH) {<br>            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);<br>            _wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);<br>            netTokenMintSy = inp.netTokenIn;<br>        } else {<br>            _swapTokenInput(inp);<br>            netTokenMintSy = _selfBalance(inp.tokenMintSy);<br>        }<br><br>        netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);<br>    }<br><br>function _swapTokenInput(TokenInput calldata inp) internal {<br>        if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);<br>        else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);<br><br>        IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(<br>            inp.tokenIn,<br>            inp.netTokenIn,<br>            inp.swapData<br>        );<br>    }</pre><p>사용자는 mintSyFromToken, redeemSyToToken 함수를 호출하여, SY Token을 발행 및 상환할 수 있다. mintSyFromToken함수는 _mintSyFromToken를 호출하는데, swapType에 따라 입력 받은 토큰의 타입에 따라 매칭이 되는 SY 토큰을 발행한다. swapType은 NONE, KYBERSWAP, ONE_INCH, ETH_WETH를 지원하는데, KYBERSWAP, ONE_INCH의 경우에는 _swapTokenInput 함수를 거쳐, Pendle Market에서 지원하는 기초자산으로 변환한다. WETH의 경우에는 ETH로 다시 변환하고, NONE의 경우에는 기초자산과 매핑되는 SY 토큰을 발행한다. 이때, 얼만큼의 SY 토큰을 발행할지는 SY 토큰마다 다르다.</p><pre>//PendleAaveV3SY<br>function _deposit(<br>        address tokenIn,<br>        uint256 amountDeposited<br>    ) internal virtual override returns (uint256 amountSharesOut) {<br>        if (tokenIn == underlying) {<br>            IAaveV3Pool(aavePool).supply(underlying, amountDeposited, address(this), 0);<br>        }<br>        amountSharesOut = AaveAdapterLib.calcSharesFromAssetUp(amountDeposited, _getNormalizedIncome());<br>    }<br><br>//sAPE<br>function _deposit(address, uint256 amountDeposited) internal virtual override returns (uint256 amountSharesOut) {<br>        // Respecting APE&#39;s deposit invariant<br>        if (amountDeposited &lt; MIN_APE_DEPOSIT) {<br>            revert Errors.SYApeDepositAmountTooSmall(amountDeposited);<br>        }<br><br>        _harvestAndCompound();<br><br>        // As SY Base is pulling the tokenIn first, the totalAsset should exclude user&#39;s deposit<br>        if (totalSupply() == 0) {<br>            amountSharesOut = amountDeposited - MINIMUM_LIQUIDITY;<br>            _mint(address(1), MINIMUM_LIQUIDITY);<br>        } else {<br>            uint256 priorTotalAssetOwned = getTotalAssetOwned() - amountDeposited;<br>            amountSharesOut = (amountDeposited * totalSupply()) / priorTotalAssetOwned;<br>        }<br>    }<br><br>//PendleUniETHSY<br>function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {<br>        if (tokenIn == NATIVE) {<br>            amountSharesOut = IBedrockStaking(bedrockStaking).mint{value: amountDeposited}(0, type(uint256).max);<br>        } else {<br>            amountSharesOut = amountDeposited;<br>        }<br>    }</pre><p>위는 PendleAaveV3SY, sAPE, PendleUniETHSY의 _deposit 함수이다. PendleAaveV3SY은 들어오는 토큰이 기초자산인 경우에는 aavePool에 공급하고, 공급된 자산을 기반으로 shares를 계산하는 반면에, sAPE는 SY 토큰 컨트랙트가 하나의 Pool처럼 동작하는 방식을 볼 수 있다. PendleUniETHSY이 경우에는 eth인 경우에는 BedrockStaking에 예치하고, 기초자산인 경우에는 입력 받은 양 그대로 1:1로 민팅되는 것을 볼 수 있다.</p><pre>function _redeemSyToToken(<br>        address receiver,<br>        address SY,<br>        uint256 netSyIn,<br>        TokenOutput calldata out,<br>        bool doPull<br>    ) internal returns (uint256 netTokenOut) {<br>        SwapType swapType = out.swapData.swapType;<br><br>        if (swapType == SwapType.NONE) {<br>            netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);<br>        } else if (swapType == SwapType.ETH_WETH) {<br>            netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull); // ETH:WETH is 1:1<br><br>            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);<br><br>            _transferOut(out.tokenOut, receiver, netTokenOut);<br>        } else {<br>            uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);<br><br>            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemed, out.swapData);<br><br>            netTokenOut = _selfBalance(out.tokenOut);<br><br>            _transferOut(out.tokenOut, receiver, netTokenOut);<br>        }<br><br>        if (netTokenOut &lt; out.minTokenOut) revert(&quot;Slippage: INSUFFICIENT_TOKEN_OUT&quot;);<br>    }</pre><p>SY 토큰을 상환할 때도 마찬가지이다. 먼저, 발행때와 마찬가지로 swapType에 따라 SY 토큰 상환을 다르게 처리한다. 이때, doPull은 라우터가 사용자로부터 SY 토큰을 approve 받아서 처리할지에 대한 플래그 값이다. SY 토큰에 해당하는 기초자산을 비율대로 소각하여, 반환한다. 단, 슬리피지가 발생할 수 있어, 슬리피지에 대한 검증을 수행한다.</p><h3>Reference</h3><ol><li><a href="https://docs.pendle.finance/Developers/Contracts/PendleRouter">https://docs.pendle.finance/Developers/Contracts/PendleRouter</a></li><li><a href="https://github.com/pendle-finance/pendle-core-v2-public/blob/main/contracts/interfaces/IPActionMiscV3.sol">https://github.com/pendle-finance/pendle-core-v2-public/blob/main/contracts/interfaces/IPActionMiscV3.sol</a></li><li><a href="https://github.com/pendle-finance/pendle-core-v2-public/blob/77b3630c82412b580bce6cd4a32f2c385bbb7970/contracts/interfaces/IPActionSwapPTV3.sol#L46-L69">https://github.com/pendle-finance/pendle-core-v2-public/blob/77b3630c82412b580bce6cd4a32f2c385bbb7970/contracts/interfaces/IPActionSwapPTV3.sol#L46-L69</a></li><li><a href="https://github.com/pendle-finance/pendle-core-v2-public/blob/77b3630c82412b580bce6cd4a32f2c385bbb7970/contracts/interfaces/IPActionSwapYTV3.sol#L45-L93">https://github.com/pendle-finance/pendle-core-v2-public/blob/77b3630c82412b580bce6cd4a32f2c385bbb7970/contracts/interfaces/IPActionSwapYTV3.sol#L45-L93</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=145f39c82786" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pendle Finance — #2 SY Token, Yield Contract Implementation]]></title>
            <link>https://medium.com/@voidgun93/pendle-finance-2-sy-token-yield-contract-implementation-6f2f8beeb7a1?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f2f8beeb7a1</guid>
            <category><![CDATA[defi]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[yield-farming]]></category>
            <category><![CDATA[derivatives]]></category>
            <category><![CDATA[pendle-finance]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Tue, 21 May 2024 02:17:48 GMT</pubDate>
            <atom:updated>2024-05-21T02:17:48.883Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pendle Finance — #2 SY Token, Yield Contract Implementation</h3><p>이번 글에서는 SY Token, Yield 컨트랙트의 구현체를 살펴봄으로써, SY Token (EIP-5115)와 SY 토큰을 어떻게 PT와 YT로 토큰을 분리하는지, 그리고 PT 토큰이 어떻게 다시 SY 토큰으로 변환되는지 확인하도록 한다.</p><h3>Backgrounds</h3><h4>ERC-5115 [1]</h4><p>ERC-5115는 Pendle 팀에서 제안한 SY 토큰 표준으로, 이는 수익을 생성하는 자산($stETH, $aUSDC, $GLP, $LOOKS)에 대한 입출금 및 잔액확인 기능을 ERC-20에 추가하였다. ERC-4626의 기능도 포함하며, AMM 유동성 토큰 및 보상 토큰과 같은 다양한 수익 생성 매커니즘을 지원한다.</p><p>ERC-4626은 특정 vault 기반의 수익성 자산에 초점을 맞춘다. 즉, ERC-4626은 특정 vault에 대한 자산 하나에 대해서만 예치, 인출을 지원한다. 하지만, ERC-5115는 다양한 수익성 자산을 받아 SY 토큰으로 래핑함으로써, 동일한 인터페이스를 사용할 수 있도록 한다.</p><h3>SY Token의 주요기능</h3><p>이번 절에서는 SY Token의 주요기능인 deposit(), redeem(), exchagneRate()을 살펴보면서, SY Token이 유동성 풀과 어떻게 상호작용하는지 살펴보도록 하겠다.</p><h4>deposit()</h4><pre>function deposit(<br>        address receiver,<br>        address tokenIn,<br>        uint256 amountTokenToDeposit,<br>        uint256 minSharesOut<br>    ) external payable nonReentrant returns (uint256 amountSharesOut) {<br>        if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);<br>        if (amountTokenToDeposit == 0) revert Errors.SYZeroDeposit();<br><br>        _transferIn(tokenIn, msg.sender, amountTokenToDeposit);<br><br>        amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);<br>        if (amountSharesOut &lt; minSharesOut) revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);<br><br>        _mint(receiver, amountSharesOut);<br>        emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);<br>    }</pre><p>deposit함수는 특정 토큰을 받아, 발행하고자 하는 SY Token의 양을 계산후 계산된 양 만큼 토큰을 발행하는 함수이다. 먼저, 예치하고자하는 토큰의 주소와 예치할 양에 대해서 검증을 한다. 검증을 통과하고 나면, 얼마만큼의 SY Token을 발행할 건지 _deposit 함수에서 계산한다. _deposit함수는 override되는 함수로, 각각 SY Token마다 구현이 다르다. 가령, PendleArbitrumStakedEthSY 컨트랙트는 deposit 입력으로 받은 양을 그대로 발행하는가 반면에, sAPE 컨트랙트는 vault와 같이 shares를 계산하여 shares만큼을 반환한다.</p><pre>//PendleArbitrumStakedEthSY.sol<br>function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {<br>        return amountDeposited;<br>}<br><br>//sAPE.sol<br>function _deposit(address, uint256 amountDeposited) internal virtual override returns (uint256 amountSharesOut) {<br>        // Respecting APE&#39;s deposit invariant<br>        if (amountDeposited &lt; MIN_APE_DEPOSIT) {<br>            revert Errors.SYApeDepositAmountTooSmall(amountDeposited);<br>        }<br><br>        _harvestAndCompound();<br><br>        // As SY Base is pulling the tokenIn first, the totalAsset should exclude user&#39;s deposit<br>        if (totalSupply() == 0) {<br>            amountSharesOut = amountDeposited - MINIMUM_LIQUIDITY;<br>            _mint(address(1), MINIMUM_LIQUIDITY);<br>        } else {<br>            uint256 priorTotalAssetOwned = getTotalAssetOwned() - amountDeposited;<br>            amountSharesOut = (amountDeposited * totalSupply()) / priorTotalAssetOwned;<br>        }<br>}</pre><p>발행하는 토큰의 양을 계산하는 방식이 다른 이유는 underlying token의 특성을 고려하기 때문이다. underlying token이 이미 shares를 포함하는 경우에는 SY Token을 1:1로 발행하는 것이 적절하나, 그렇지 않은 경우에는 sAPE 처럼 shares를 따로 계산하여, 발행하는 것이 SY Token의 가치를 보전하기에 좋을 수 있다.</p><h4>redeem()</h4><pre>function redeem(<br>        address receiver,<br>        uint256 amountSharesToRedeem,<br>        address tokenOut,<br>        uint256 minTokenOut,<br>        bool burnFromInternalBalance<br>    ) external nonReentrant returns (uint256 amountTokenOut) {<br>        if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);<br>        if (amountSharesToRedeem == 0) revert Errors.SYZeroRedeem();<br><br>        if (burnFromInternalBalance) {<br>            _burn(address(this), amountSharesToRedeem);<br>        } else {<br>            _burn(msg.sender, amountSharesToRedeem);<br>        }<br><br>        amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);<br>        if (amountTokenOut &lt; minTokenOut) revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);<br>        emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);<br>}</pre><p>redeem()함수는 SY Token을 받아 소각하고, 원래의 underlying token을 가져갈 수 있도록 하는 함수이다. 한가지 재미있는 점은 burnFromInternalBalance에 따라, 두가지 모드 방식으로 redeem()을 할 수 있다. burnFromInternalBalance이 true가 되면, 사용자가 컨트랙트에 SY Token을 보내고, redeem을 요청하는 방식이고, false를 하게 되면 사용자의 주소에 직접 burn을 하는 방식이다. 위에서 설명한 바와 마찬가지로, 받는 underlying token의 양은 SY Token 마다 다르다.</p><h4>exchangeRate()</h4><p>exchangeRate함수는 1 SY Token이 underlying token으로 교환될 때의 교환비를 반환한다. 이 역시 SY Token 별로 값을 반환하는 방법이 다르다. PendleAaveV3SY 컨트랙트는aavePool에서 underlying token에서 NormalizedIncome을 가져온다. PendleL2RTSY 컨트랙트는 설정해둔 exchange oracle에서 비율을 가져온다. PendleArbitrumStakedEthSY는 체인링크 피드에서 값을 가져오는 방식을 채택했다.</p><pre>//PendleAaveV3SY<br>function exchangeRate() public view virtual override returns (uint256) {<br>        return _getNormalizedIncome() / 1e9;<br>}<br><br>function _getNormalizedIncome() internal view returns (uint256) {<br>        return IAaveV3Pool(aavePool).getReserveNormalizedIncome(underlying);<br>}<br><br>//PendleL2RTSY<br>function exchangeRate() public view override returns (uint256) {<br>        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();<br>}<br><br>//PendleArbitrumStakedEthSY<br>function exchangeRate() public view override returns (uint256) {<br>        return IChainlinkAggregator(chainlinkFeed).latestAnswer().Uint();<br>}</pre><h3>Reward가 있는 SY Token [2]</h3><p>이번 절에서는 reward가 있는 SY Token이 reward를 어떻게 분배하는지에 대해 살펴보도록 하겠다. [2]에 따르면, 리워드는 t시점과 t* 시점(t &gt; t*) 사이에 발생한 리워드에 대해 shares만큼 유저에게 돌아가는 구조이다. 사용자는 clainReward를 호출함으로써, 자신에게 할당된 reward를 수령할 수 있다.</p><pre>//SYBaseWithRewards<br>function claimRewards(<br>        address user<br>    ) external virtual override nonReentrant whenNotPaused returns (uint256[] memory rewardAmounts) {<br>        _updateAndDistributeRewards(user);<br>        rewardAmounts = _doTransferOutRewards(user, user);<br><br>        emit ClaimRewards(user, _getRewardTokens(), rewardAmounts);<br>}<br><br>//RewardManagerAbstract<br>function _updateAndDistributeRewards(address user) internal virtual {<br>        _updateAndDistributeRewardsForTwo(user, address(0));<br>    }<br><br>    function _updateAndDistributeRewardsForTwo(address user1, address user2) internal virtual {<br>        (address[] memory tokens, uint256[] memory indexes) = _updateRewardIndex();<br>        if (tokens.length == 0) return;<br><br>        if (user1 != address(0) &amp;&amp; user1 != address(this)) _distributeRewardsPrivate(user1, tokens, indexes);<br>        if (user2 != address(0) &amp;&amp; user2 != address(this)) _distributeRewardsPrivate(user2, tokens, indexes);<br>    }<br><br>    // should only be callable from `_updateAndDistributeRewardsForTwo` to guarantee user != address(0) &amp;&amp; user != address(this)<br>    function _distributeRewardsPrivate(address user, address[] memory tokens, uint256[] memory indexes) private {<br>        assert(user != address(0) &amp;&amp; user != address(this));<br><br>        uint256 userShares = _rewardSharesUser(user);<br><br>        for (uint256 i = 0; i &lt; tokens.length; ++i) {<br>            address token = tokens[i];<br>            uint256 index = indexes[i];<br>            uint256 userIndex = userReward[token][user].index;<br><br>            if (userIndex == 0) {<br>                userIndex = INITIAL_REWARD_INDEX.Uint128();<br>            }<br><br>            if (userIndex == index) continue;<br><br>            uint256 deltaIndex = index - userIndex;<br>            uint256 rewardDelta = userShares.mulDown(deltaIndex);<br>            uint256 rewardAccrued = userReward[token][user].accrued + rewardDelta;<br><br>            userReward[token][user] = UserReward({index: index.Uint128(), accrued: rewardAccrued.Uint128()});<br>        }<br>    }</pre><p>claimRewards는 처음에 이전 t*에서 현재 t시점까지 누적된 reward의 값을 _updateAndDistributeRewards를 호출하여 업데이트한다. 함수 내부에서_distributeRewardsPrivate을 호출하게 되는데, 위의 함수는 특정 리워드 토큰 i에 리워드의 양을 누적된 양을 가져와 마지막으로 claim된 사용자의 리워드를 빼서 delatIndex를 계산한다. 이 값을 사용자의 지분만큼 곱하여, 사용자에게 줄 reward를 계산한다(rewardDelta). 마지막으로, 사용자의 리워드의 상태값을 업데이트한다.</p><pre>function _doTransferOutRewards(<br>        address user,<br>        address receiver<br>    ) internal virtual override returns (uint256[] memory rewardAmounts) {<br>        address[] memory tokens = _getRewardTokens();<br>        rewardAmounts = new uint256[](tokens.length);<br>        for (uint256 i = 0; i &lt; tokens.length; i++) {<br>            rewardAmounts[i] = userReward[tokens[i]][user].accrued;<br>            if (rewardAmounts[i] != 0) {<br>                userReward[tokens[i]][user].accrued = 0;<br>                rewardState[tokens[i]].lastBalance -= rewardAmounts[i].Uint128();<br>                _transferOut(tokens[i], receiver, rewardAmounts[i]);<br>            }<br>        }<br>}</pre><p>다음으로 _doTransferOutRewards()를 호출하는데, 이는 이전에 업데이트된 사용자의 리워드를 가져와 사용자에게 reward를 전송한다. 구현체를 보면 알수 있지만, reward 토큰은 하나 이상이 될 수 있고, 이는 사용자의 shares만큼 분배된다는 것을 알 수 있다.</p><h3>Yield Contract</h3><p>PendleYieldTokenV2는 유동화된 수익을 관리하고 분배하는 역할을 수행한다. 이 컨트랙트는 사용자가 특정 자산 (SY)를 예치하여 PT Token과 YT Token을 발행하고, 만기 이후에는 다시 SY로 교환할수 있도록 한다.</p><h4>주요 변수</h4><pre>constructor(<br>    address _SY,<br>    address _PT,<br>    string memory _name,<br>    string memory _symbol,<br>    uint8 __decimals,<br>    uint256 _expiry,<br>    bool _doCacheIndexSameBlock<br>) PendleERC20(_name, _symbol, __decimals) {<br>    SY = _SY;<br>    PT = _PT;<br>    expiry = _expiry;<br>    factory = msg.sender;<br>    doCacheIndexSameBlock = _doCacheIndexSameBlock;<br>}</pre><p>Yield Contract가 배포될때는 SY Token의 주소, PT Token의 주소, 그리고 만기일을 받는다. _doCacheIndexSameBlock도 생성자로 받는데, 이는 현재 블록에서 캐시된 _pyIndexStored를 사용할지 말지에 대한 것을 결정하는 변수이다. 해당 변수는 PT를 발행할때 사용되는 변수로, PY 인덱스를 사용하여, <strong>발행할 양을 계산</strong>한다.</p><h4>PT, YT 발행</h4><pre>function mintPY(<br>        address receiverPT,<br>        address receiverYT<br>    ) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {<br>        address[] memory receiverPTs = new address[](1);<br>        address[] memory receiverYTs = new address[](1);<br>        uint256[] memory amountSyToMints = new uint256[](1);<br><br>        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (receiverPT, receiverYT, _getFloatingSyAmount());<br><br>        uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);<br>        amountPYOut = amountPYOuts[0];<br>}<br><br>function _getFloatingSyAmount() internal view returns (uint256 amount) {<br>        amount = _selfBalance(SY) - syReserve;<br>        if (amount == 0) revert Errors.YCNoFloatingSy();<br>}</pre><p>PY를 발행하는 함수는 위와 같다. PT와 YT를 수령할 주소를 입력으로 받고, 컨트랙트가 가지고 있는 SY 토큰의 양을 가져온다. 이때, syReserve 값을 빼게되는데, syReserve값은 만기일까지 쌓인 리워드와 이자를 treasury가 받을 수 있도록 하는 함수인 redeemInterestAndRewardsPostExpiryForTreasury가 호출될 때 업데이트 된다. 또한, 컨트랙트가 가지고 잇는 SY 잔액이 변경될 때 업데이트 된다. 이는 _updateSyReserve를 통해 이루어진다. 즉, 마지막에 SY 잔액이 업데이트 될때와 현재의 SY 잔액의 차를 amountSyToMints에 저장한다.</p><pre>function _mintPY(<br>        address[] memory receiverPTs,<br>        address[] memory receiverYTs,<br>        uint256[] memory amountSyToMints<br>    ) internal returns (uint256[] memory amountPYOuts) {<br>        amountPYOuts = new uint256[](amountSyToMints.length);<br><br>        uint256 index = _pyIndexCurrent();<br><br>        for (uint256 i = 0; i &lt; amountSyToMints.length; i++) {<br>            amountPYOuts[i] = _calcPYToMint(amountSyToMints[i], index);<br><br>            _mint(receiverYTs[i], amountPYOuts[i]);<br>            IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);<br><br>            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);<br>        }<br>    }<br><br>function _pyIndexCurrent() internal returns (uint256 currentIndex) {<br>        if (doCacheIndexSameBlock &amp;&amp; pyIndexLastUpdatedBlock == block.number) return _pyIndexStored;<br><br>        uint128 index128 = PMath.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored).Uint128();<br><br>        currentIndex = index128;<br>        _pyIndexStored = index128;<br>        pyIndexLastUpdatedBlock = uint128(block.number);<br>    }</pre><p>_mintPY에서 본격적으로 PT토큰과 YT 토큰을 발행한다. 발행 프로세스는 아래와 같다. 이때, 입력으로 받은 SY 토큰을 교환비율을 적용하여, 발행할 PT와 YT 토큰 수량을 결정한다.</p><ol><li>index 계산(SY 토큰의 교환비율을 가져옴)</li><li>index를 기반으로 발행할 PY 토큰 계산</li><li>같은 수량의 YT와 PT 토큰 발행</li></ol><h4>PT, YT 소각</h4><pre>function redeemPY(address receiver) external nonReentrant updateData returns (uint256 amountSyOut) {<br>        address[] memory receivers = new address[](1);<br>        uint256[] memory amounts = new uint256[](1);<br>        (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());<br><br>        uint256[] memory amountSyOuts;<br>        amountSyOuts = _redeemPY(receivers, amounts);<br><br>        amountSyOut = amountSyOuts[0];<br>    }<br><br>function _getAmountPYToRedeem() internal view returns (uint256) {<br>        if (!isExpired()) return PMath.min(_selfBalance(PT), balanceOf(address(this)));<br>        else return _selfBalance(PT);<br>    }</pre><p>PT, YT는 redeemPY를 통해서 자산을 수령할 수 있다. SY 토큰으로 변환된다. 우선 _getAmountPYToRedeem함수를 통해서 우선 만기일이 지났는지 아닌지 판단한다. 만기일이 지나지 않은 경우 YT 컨트랙트가 가지고 있는 PT와 컨트랙트의 YT를 비교하여, 작은 값을 리턴하고, 만기일이 지난 경우에는 컨트랙트가 가지고 있는 PT 값을 반환한다.</p><pre>function _redeemPY(<br>        address[] memory receivers,<br>        uint256[] memory amountPYToRedeems<br>    ) internal returns (uint256[] memory amountSyOuts) {<br>        uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();<br>        IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);<br>        if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);<br><br>        uint256 index = _pyIndexCurrent();<br>        uint256 totalSyInterestPostExpiry;<br>        amountSyOuts = new uint256[](receivers.length);<br><br>        for (uint256 i = 0; i &lt; receivers.length; i++) {<br>            uint256 syInterestPostExpiry;<br>            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);<br>            _transferOut(SY, receivers[i], amountSyOuts[i]);<br>            totalSyInterestPostExpiry += syInterestPostExpiry;<br><br>            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountSyOuts[i]);<br>        }<br><br>        address treasury = IPYieldContractFactory(factory).treasury();<br>        _transferOut(SY, treasury, totalSyInterestPostExpiry);<br>}<br><br>function _calcSyRedeemableFromPY(<br>        uint256 amountPY,<br>        uint256 indexCurrent<br>    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {<br>        syToUser = SYUtils.assetToSy(indexCurrent, amountPY);<br>        if (isExpired()) {<br>            uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);<br>            syInterestPostExpiry = totalSyRedeemable - syToUser;<br>        }<br>}</pre><p>반환될 PT(혹은 YT) 토큰의 양만큼 PT를 소각하고, 만기일이 지난 경우에는 YT 토큰도 소각한다. 다음으로 교환비율을 가져와 변환될 SY 토큰의 수량을 계산한다. 만기일이 지나게 되면, totalSyRedeemable와 syInterestPostExpiry을 계산하여 반환한다. 다음으로 SY 토큰을 전송하고, treasury로 수수료를 전송하여 마무리한다.</p><h3>Reference</h3><ol><li><a href="https://eips.ethereum.org/EIPS/eip-5115">https://eips.ethereum.org/EIPS/eip-5115</a></li><li>V. Nguyen, and L. Vuong, “Standardize Yield — A token standard for yield generating mechanism,” Pendle, Oct. 14, 2022.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f2f8beeb7a1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pendle Finance — #1 Overview and SY, PT, and YT Tokens]]></title>
            <link>https://medium.com/@voidgun93/pendle-finance-1-overview-and-sy-pt-and-yt-tokens-c2516e76fc29?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2516e76fc29</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[pendle-finance]]></category>
            <category><![CDATA[defi]]></category>
            <category><![CDATA[yield]]></category>
            <category><![CDATA[derivatives]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Tue, 14 May 2024 02:52:06 GMT</pubDate>
            <atom:updated>2024-05-16T07:08:18.078Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pendle Finance — #1 Overview and SY, PT, and YT Tokens</h3><p>이번 시리즈에서는 Pendle에 대해서 다루면서, Pendle의 특징은 무엇이고, Pendle은 이를 어떻게 구현했는지에 대해 다뤄보고자 한다. 특히, 이번 글에 대해서는 Pendle에서의 주된 개념을 다루고 소개하도록 한다.</p><p>Pendle은 원금과 이자를 분리함으로써, 자산의 효율성을 극대화하도록 한다. 이를 분리함으로써, 투자자는 개인 상황 혹은 시장상황에 따라 여러 전략을 수행할 수 있다. 가령, 갑작스럽게 현금이 필요한 경우 원금을 가져와 할인하여 팔 수 도 있다. 혹은, 어떤 자산의 이자에 대한 부분만 구매할 수 있다. 즉, 원금과 이자를 분리함으로써 어떤 포지션이든 구축할 수 있다는 점이 Pendle의 가장 큰 포인트이다. 이를 이해하기 위해 이번 글에서는 SY, PT, YT에 대해 간략하게 소개한다.</p><h3>Yield Tokenization (SY, PT, YT) [1]</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i89Z3tPEiuW9i3rI.png" /></figure><p>Pendle을 이용하기 위해서는 기초자산을 SY로 래핑해야한다(stETH -&gt; SY-stETH). 이때의 기초자산은 Yield Bearing Tokens이다. PT, YT로 나뉜 기초자산은 Pendle AMM에서 거래된다. PT는 원금에 해당하는 부분이고, YT는 이자에 해당하는 부분이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h7jfRDPIRfyy_EvXgM7mpQ.png" /></figure><p> 위의 그림은 기초자산을 PT, YT로 분리하는 것을 보여준다. <em>$stETH</em>를 Pendle에 예치하면 <em>$SY-stETH</em>가 발행되고 이는 <em>$PT-stETH</em>와 <em>$YT-stETH</em>로 나눌수 있다. 100 <em>$stETH</em>가지고 mint요청을 하면 100 <em>$PT-stETH</em>와 100 <em>$YT-stETH</em>로 나누어서 받을 수 있다. 100 $PT-stETH를 만기일까지 보유하고 있다면, 100 <em>$ETH</em>에 상응하는 100 <em>$stETH</em>를 수령할 수 있고, 100 <em>$YT-stETH</em>는 만기일까지 보유하고 있다면, 현재 시점에서 만기일까지 100 <em>$stETH</em>에 상응하는 이자를 받을 수 있다.</p><h3>PT와 Fixed APY</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Yntvb13xKS9caKz2.png" /></figure><p>PT는 이자 포함 토큰과 1:1로 교환된다. 위의 그림처럼 peepo가 1 PT cDAI를 0.9DAI로 샀다고 해보자. 1년후 만기일때, peepo는 1DAI를 얻을 수 있고, 11%의 수익을 얻은 셈이다. 이러한 방식으로 고정 수익률을 달성할 수 있다. 이 <strong>고정 수익률이 Fixed APY</strong>이다. 주의할 점은 <strong><em>PT는 기초자산이 아닌 회계 자산에 대해서 1:1</em></strong>이라는 점이다. 가령, Renzo ezETH의 가치는 시간이 지남에 따라 증가한다. 따라서, 보유한 1 <em>$PT-ezETH</em>를 1 <em>$ezETH</em>로 받는 것이 아닌 1 <em>$ETH</em>상당의 <em>$ezETH</em>를 상환받는 것이다. 이러한 PT의 상환 가치는 <a href="https://app.pendle.finance/trade/markets">이 링크</a>에서 확인 가능하다.</p><p>앞절에서 살펴본 바와 같이 PT를 구매한다는 것은 이자율을 고정하겠다는 뜻이다. 다시 말하면, PT를 구매한다는 것은 이자율에 숏포지션을 잡는것과 같은 효과이다. 가령, 만기일에 stETH의 평균 이자율(Underlying APY)이 5%이고, 현재 Fixed APY가 6%라고 한다면, PT를 구매함으로써 이득을 볼 수 있다. 또한, PT자체를 매수하고 매도함으로써, 시세 차익을 노릴수 있다. PT의 가격은 아래의 경우에 올라가는 경향이 있다.</p><ul><li>Time: 만기일에 도래할 수록 PT의 가격은 올라간다.</li><li>Implied APY: Implied APY가 하락하면 PT의 가격이 올라간다. 후술하겠지만, Implied APY는 기초자산의 이자가 미래에 얼마까지 올라갈지를 나타내는 시장의 예측이다. 즉, Implied APY가 떨어진다는 것은 시장이 이자율을 하락할 것이라고 예상하는 것이고, 다시말하면, PT를 구매함으로써 이자율에 숏포지션을 잡는 것이 유리하기 때문이다.</li><li>기초자산의 가격 상승</li></ul><h3>YT, Underlying APY 그리고 Implied APY [4]</h3><p>YT는 기초 수익률 자산의 수익률을 나타낸다. YT를 보유하고 있음으로써, 기초 자산에 대한 이자가 만기일까지 유저에게 간다. 이를 underlying apy라고 하는데, 가령, <em>$PT-stETH</em>의 underlying apy는 <em>$stETH</em>의 실제 이자율을 의미한다. 가령, 10 YT-stETH를 5일동안 가지고 있다면, 10 ETH를 Lido에 같은 기간 예치한 이자율과 동일한 이자를 받을 수 있다.</p><p>YT의 가치는 만기일에 가까워질 수록 $0로 수렴하게 되는 경향을 보이는데, 사용자는 해당 시점까지 모은 총 수익률이 YT를 구매한 비용보다 높을 때 수익을 얻게 된다. 여기에서 Implied APY는 어떤 자산의 미래 수익률에 대한 시장의 합의이다. 이 값은 YT와 PT가격 비율에 기초하여 계산되며, 아래의 공식으로 나타낸다. Underlying APY가 내가 지불한 이자율 또는 Implied APY보다 높으면 수익을 얻는다.</p><ul><li>Underlying APY: YT에 연결된 기초자산의 현재 수익률</li><li>Implied APY: YT의 거래 가격을 기준으로 YT가 향후에 제공할 것으로 예상되는 연간 수익률, 즉 현재 YT의 가격인 셈이다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/1*fYWlI52p-UepA5FcmzNCbw.png" /></figure><p>Pendle AMM에서 1 <em>$PT-stETH</em>는 0.96 <em>$stETH</em>, 1 <em>$YT-stETH</em>는 0.04 <em>$stETH</em>라고 가정해보자. 그리고, 1 <em>$YT-stETH</em>를 구매하였다고 해보자. 만기일에 도래해서 실제로 받은 이자가 0.05라면, 25%의 수익을 얻은 것이다. Implied APY가 0.04%일때 구매했고, 0.01의 이자를 추가로 얻었기 때문이다. 즉, YT를 가지고 있다는 것은 이자율에 대해서 롱포지션을 잡는 것이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0mhIzI-UMariMyZ4tHwuMw.png" /></figure><p>실제 Pendle Market을 보면, 위와 같이 구성되어 있다. Implied APY를 보면 4.2%라고 되어 있는데, 이는 1 <em>$YT-stETH</em>의 가격이 1 <em>$stETH</em>의 4.2%라는 것이다. 즉, 0.04 <em>$stETH</em>가 1 <em>$YT-stETH</em>의<em> </em>현재 가격이다. 다음, Underlying APY가 5%인데, 이는 현재 기초자산이 5%의 이율을 준다는 것이다. 따라서, 1 $YT-stETH를 매수하게 되면, 대략 만기일까지 5%의 이자를 받는 다는 것이다.(Underlying APY가 변하지 않는 다는 가정) 다시 말하면, 이익으로는 1%의 이익을 볼 수 있고, 이는 25%의 수익률을 볼 수 있다는 뜻이다.</p><h3>Reference</h3><ol><li><a href="https://docs.pendle.finance/Introduction#what-does-pendle-do">https://docs.pendle.finance/Introduction#what-does-pendle-do</a></li><li><a href="https://docs.pendle.finance/ProtocolMechanics/YieldTokenization/YT">https://docs.pendle.finance/ProtocolMechanics/YieldTokenization/YT</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2516e76fc29" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lido.sol 코드 Deep Dive — #6 Accounting Oracle]]></title>
            <link>https://medium.com/@voidgun93/lido-sol-%EC%BD%94%EB%93%9C-deep-dive-6-accounting-oracle-6a1e9963df50?source=rss-2233b8292fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a1e9963df50</guid>
            <category><![CDATA[lido-deep-dive]]></category>
            <category><![CDATA[lido-report]]></category>
            <category><![CDATA[lido-finance]]></category>
            <category><![CDATA[lido]]></category>
            <category><![CDATA[accounting-oracle]]></category>
            <dc:creator><![CDATA[Louis Noh]]></dc:creator>
            <pubDate>Tue, 07 May 2024 03:52:02 GMT</pubDate>
            <atom:updated>2024-05-07T07:42:11.075Z</atom:updated>
            <content:encoded><![CDATA[<h3>Lido.sol 코드 Deep Dive — #6 Accounting Oracle과 Oracle Report 적용</h3><h3>Intro</h3><p>이전 글에서는 오프체인 오라클이 레포트를 HashConsensus에 제출하고, 컨센서스 도달의 여부를 파악후 AccountingOracle의 submitConsensusReport를 호출하는 것을 살펴보았다. 이번 글에서는 HashConsensus 컨트랙트로부터 레포트를 수신한 AccountingOracle이 이를 처리하는 프로세스를 코드로 살펴보고자 한다.</p><h3>submitConsensusReport</h3><h4>입력값 검증</h4><pre>function submitConsensusReport(bytes32 reportHash, uint256 refSlot, uint256 deadline) external {<br>        _checkSenderIsConsensusContract();<br><br>        uint256 prevSubmittedRefSlot = _storageConsensusReport().value.refSlot;<br>        if (refSlot &lt; prevSubmittedRefSlot) {<br>            revert RefSlotCannotDecrease(refSlot, prevSubmittedRefSlot);<br>        }<br><br>        uint256 prevProcessingRefSlot = LAST_PROCESSING_REF_SLOT_POSITION.getStorageUint256();<br>        if (refSlot &lt;= prevProcessingRefSlot) {<br>            revert RefSlotMustBeGreaterThanProcessingOne(refSlot, prevProcessingRefSlot);<br>        }<br><br>        if (_getTime() &gt; deadline) {<br>            revert ProcessingDeadlineMissed(deadline);<br>        }<br><br>        if (refSlot != prevSubmittedRefSlot &amp;&amp; prevProcessingRefSlot != prevSubmittedRefSlot) {<br>            emit WarnProcessingMissed(prevSubmittedRefSlot);<br>        }<br><br>        if (reportHash == bytes32(0)) {<br>            revert HashCannotBeZero();<br>        }<br><br>        emit ReportSubmitted(refSlot, reportHash, deadline);<br><br>        ConsensusReport memory report = ConsensusReport({<br>            hash: reportHash,<br>            refSlot: refSlot.toUint64(),<br>            processingDeadlineTime: deadline.toUint64()<br>        });<br><br>        _storageConsensusReport().value = report;<br>        _handleConsensusReport(report, prevSubmittedRefSlot, prevProcessingRefSlot);<br>}</pre><p>이전 글에서 살펴본바와 같이 컨센서스에 도달하면, HashConsensus는 submitConsensusReport를 호출한다. 이는 [1]에서 서술된 바와 같이 레포트를 실제로 제출하는 함수는 아니다. 컨센서스 레포트를 제출하고 이는 나중에 처리되는 패턴이다. 다시 말하면, 처리가 시작될때까지 HashConsensus는 다른 레포트에 대해 합의를 도달할 수 있기 때문이다.</p><p>위의 함수는 호출자가 컨센서스 컨트랙트인지를 확인하는데 컨센서스 컨트랙트란 HashConsensus를 가르킨다. 다음으로, 마지막으로 제출된 컨센서스 레포트의 레퍼런스 슬롯을 가져오고 제출된 레퍼런스 슬롯이 이전 슬롯인지 아닌지 판단한다. 그리고, 제출된 레포트가 실제로 처리된 슬롯을 가져와 검증을 수행한다. deadline, 레포트의 해쉬값, 이전에 처리된 레포트의 레퍼런스 슬롯, 그리고 제출된 레퍼런스 슬롯을 확인한다. 검증과정이 마무리되면, 레포트를 스토리지에 저장하고, _handleConsensusReport를 호출한다.</p><h4>_handleConsensusReport</h4><pre>function _handleConsensusReport(<br>        ConsensusReport memory /* report */,<br>        uint256 /* prevSubmittedRefSlot */,<br>        uint256 prevProcessingRefSlot<br>    ) internal override {<br>        ExtraDataProcessingState memory state = _storageExtraDataProcessingState().value;<br>        if (state.refSlot == prevProcessingRefSlot &amp;&amp; (<br>            !state.submitted || state.itemsProcessed &lt; state.itemsCount<br>        )) {<br>            emit WarnExtraDataIncompleteProcessing(<br>                prevProcessingRefSlot,<br>                state.itemsProcessed,<br>                state.itemsCount<br>            );<br>        }<br>    }</pre><p>위의 함수는 extra data가 있는 경우 이와 관련된 처리에 대한 결과를 알려준다. extra data는 submitReportExtraDataList함수를 통해 제출되는데, 이는 SUBMIT_DATA_ROLE을 가지고 있는 사람이거나, 컨센서스 멤버라면 누구나 호출할 수 있다. extra data가 제출된 레퍼런스 슬롯이 마지막 레포트가 처리된 레퍼런스 슬롯과 같고, 레포트가 제출이 안되었다면, WarnExtraDataIncompleteProcessing를 발생하여, extra data 처리에 문제가 있음을 알린다.</p><pre>function _checkMsgSenderIsAllowedToSubmitData() internal view {<br>        address sender = _msgSender();<br>        if (!hasRole(SUBMIT_DATA_ROLE, sender) &amp;&amp; !_isConsensusMember(sender)) {<br>            revert SenderNotAllowed();<br>        }<br>}</pre><h3>submitReportData</h3><pre>function submitReportData(ReportData calldata data, uint256 contractVersion) external {<br>        _checkMsgSenderIsAllowedToSubmitData();<br>        _checkContractVersion(contractVersion);<br>        _checkConsensusData(data.refSlot, data.consensusVersion, keccak256(abi.encode(data)));<br>        uint256 prevRefSlot = _startProcessing();<br>        _handleConsensusReportData(data, prevRefSlot);<br>    }</pre><h4>submitReportData — Data 검증</h4><p>컨센서스 레포트가 AccountingOracle에 등록되면 submitReportData를 호출하여 본격적으로 제출된 레포트를 반영하기 시작한다. 반영하기전 호출자, 컨트랙트 버전, 그리고 제출된 레포트에 대해서 검증을 시작한다. 아래의 항목을 검증한다.</p><ul><li>호출자가 SUBMIT_DATA_ROLE를 가지고 있거나, 컨센서스 멤버인지</li><li>컨센서스 컨트랙트 버전에 대한 검증</li><li>입력받은 레퍼런스 슬롯에 대한 검증</li><li>데드라인</li><li>data의 해시값 검증</li><li>기타 saftety checks</li></ul><p>대부분의 검증 과정은 특별한 방법을 사용하여 검증하는 것은 아니고, submitReportData을 제출한 data가 submitConsensusReport을 통해 저장된 data와 일치하는지 확인하는 과정만 거친다.</p><pre>function _checkConsensusData(uint256 refSlot, uint256 consensusVersion, bytes32 hash)<br>        internal view<br>    {<br>        ConsensusReport memory report = _storageConsensusReport().value;<br>        if (refSlot != report.refSlot) {<br>            revert UnexpectedRefSlot(report.refSlot, refSlot);<br>        }<br><br>        uint256 expectedConsensusVersion = CONSENSUS_VERSION_POSITION.getStorageUint256();<br>        if (consensusVersion != expectedConsensusVersion) {<br>            revert UnexpectedConsensusVersion(expectedConsensusVersion, consensusVersion);<br>        }<br><br>        if (hash != report.hash) {<br>            revert UnexpectedDataHash(report.hash, hash);<br>        }<br>}</pre><h4>submitReportData — _startProcessing</h4><pre>function _startProcessing() internal returns (uint256) {<br>        ConsensusReport memory report = _storageConsensusReport().value;<br>        if (report.hash == bytes32(0)) {<br>            revert NoConsensusReportToProcess();<br>        }<br><br>        _checkProcessingDeadline(report.processingDeadlineTime);<br><br>        uint256 prevProcessingRefSlot = LAST_PROCESSING_REF_SLOT_POSITION.getStorageUint256();<br>        if (prevProcessingRefSlot == report.refSlot) {<br>            revert RefSlotAlreadyProcessing();<br>        }<br><br>        LAST_PROCESSING_REF_SLOT_POSITION.setStorageUint256(report.refSlot);<br><br>        emit ProcessingStarted(report.refSlot, report.hash);<br>        return prevProcessingRefSlot;<br>}</pre><p>_startProcessing에서는 submitConsensusReport를 통해 제출된 report를 가져온다. 제출된 report의 해시 값을 확인하고, 데드라인을 확인한다. 그리고 마지막에 처리된 레포트에 대한 레퍼런스 슬롯을 가져오고, 이를 업데이트한다. 마지막으로, 마지막에 처리된 레포트의 슬롯을 반환한다.</p><h4>submitReportData — _handleConsensusReportData: sanity check와 staking module의 상태 업데이트</h4><pre>function _handleConsensusReportData(ReportData calldata data, uint256 prevRefSlot) internal {<br>        if (data.extraDataFormat == EXTRA_DATA_FORMAT_EMPTY) {<br>            if (data.extraDataHash != bytes32(0)) {<br>                revert UnexpectedExtraDataHash(bytes32(0), data.extraDataHash);<br>            }<br>            if (data.extraDataItemsCount != 0) {<br>                revert UnexpectedExtraDataItemsCount(0, data.extraDataItemsCount);<br>            }<br>        } else {<br>            if (data.extraDataFormat != EXTRA_DATA_FORMAT_LIST) {<br>                revert UnsupportedExtraDataFormat(data.extraDataFormat);<br>            }<br>            if (data.extraDataItemsCount == 0) {<br>                revert ExtraDataItemsCountCannotBeZeroForNonEmptyData();<br>            }<br>             if (data.extraDataHash == bytes32(0)) {<br>                revert ExtraDataHashCannotBeZeroForNonEmptyData();<br>            }<br>        }<br><br>        IOracleReportSanityChecker(LOCATOR.oracleReportSanityChecker())<br>            .checkAccountingExtraDataListItemsCount(data.extraDataItemsCount);<br><br>        ILegacyOracle(LEGACY_ORACLE).handleConsensusLayerReport(<br>            data.refSlot,<br>            data.clBalanceGwei * 1e9,<br>            data.numValidators<br>        );<br><br>        uint256 slotsElapsed = data.refSlot - prevRefSlot;<br><br>        IStakingRouter stakingRouter = IStakingRouter(LOCATOR.stakingRouter());<br>        IWithdrawalQueue withdrawalQueue = IWithdrawalQueue(LOCATOR.withdrawalQueue());<br><br>        _processStakingRouterExitedValidatorsByModule(<br>            stakingRouter,<br>            data.stakingModuleIdsWithNewlyExitedValidators,<br>            data.numExitedValidatorsByStakingModule,<br>            slotsElapsed<br>        );<br><br>        withdrawalQueue.onOracleReport(<br>            data.isBunkerMode,<br>            GENESIS_TIME + prevRefSlot * SECONDS_PER_SLOT,<br>            GENESIS_TIME + data.refSlot * SECONDS_PER_SLOT<br>        );<br><br>        ILido(LIDO).handleOracleReport(<br>            GENESIS_TIME + data.refSlot * SECONDS_PER_SLOT,<br>            slotsElapsed * SECONDS_PER_SLOT,<br>            data.numValidators,<br>            data.clBalanceGwei * 1e9,<br>            data.withdrawalVaultBalance,<br>            data.elRewardsVaultBalance,<br>            data.sharesRequestedToBurn,<br>            data.withdrawalFinalizationBatches,<br>            data.simulatedShareRate<br>        );<br><br>        _storageExtraDataProcessingState().value = ExtraDataProcessingState({<br>            refSlot: data.refSlot.toUint64(),<br>            dataFormat: data.extraDataFormat.toUint16(),<br>            submitted: false,<br>            dataHash: data.extraDataHash,<br>            itemsCount: data.extraDataItemsCount.toUint16(),<br>            itemsProcessed: 0,<br>            lastSortingKey: 0<br>        });<br>    }</pre><p>마지막에 처리된 레포트의 레퍼런스 슬롯을 가져왔다면, 이를 반영할 data와 함께 _handleConsensusReportData를 호출하여, 레포트를 반영하는 작업을 본격적으로 시작한다. 아래의 그림은 위의 과정을 나타낸 것이다[2].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tmcJbv_AOl_-OSkn5v6DlA.png" /></figure><p>우선, extra data가 있는지 없는지 확인하고, 포맷을 확인한다. extra data가 없다면, extra data hash 필드가 비어 있는지 extra data의 수가 0인지 확인한다. extra data가 있다면, extra data hash 필드에 데이터가 있는지, 포맷이 맞는지, 아이템의 수가 0이 아닌지 확인한다.</p><pre>function checkAccountingExtraDataListItemsCount(uint256 _extraDataListItemsCount)<br>        external<br>        view<br>    {<br>        uint256 limit = _limits.unpack().maxAccountingExtraDataListItemsCount;<br>        if (_extraDataListItemsCount &gt; limit) {<br>            revert MaxAccountingExtraDataItemsCountExceeded(limit, _extraDataListItemsCount);<br>        }<br>}</pre><p>다음으로, oracleReportSanityChecker의 checkAccountingExtraDataListItemsCount를 호출하여 data의 extra data item의 길이가 허용된 limit을 초과하는지 확인한다. extra data에 대한 검증이 마무리되었다면, Legacy Oracle의 handleConsensusLayerReport를 호출한다. handleConsensysLayerReport는 제출한 레포트 아이디가 실행될 epochId를 갱신한다.</p><pre>function _processStakingRouterExitedValidatorsByModule(<br>        IStakingRouter stakingRouter,<br>        uint256[] calldata stakingModuleIds,<br>        uint256[] calldata numExitedValidatorsByStakingModule,<br>        uint256 slotsElapsed<br>    ) internal {<br>...<br><br>        uint256 newlyExitedValidatorsCount = stakingRouter.updateExitedValidatorsCountByStakingModule(<br>            stakingModuleIds,<br>            numExitedValidatorsByStakingModule<br>        );<br><br>        uint256 exitedValidatorsRatePerDay =<br>            newlyExitedValidatorsCount * (1 days) /<br>            (SECONDS_PER_SLOT * slotsElapsed);<br><br>        IOracleReportSanityChecker(LOCATOR.oracleReportSanityChecker())<br>            .checkExitedValidatorsRatePerDay(exitedValidatorsRatePerDay);<br>    }</pre><p>이후 staking router의 updateExitedValidatorsCountByStakingModule 을 호출하여, 각 스테이킹 모듈에게 탈퇴한 validator의 수를 전달하고, 이전 레포트 제출 시점과 현재 레포트 제출 시점에서의 탈퇴한 validator의 수를 반환한다. 주의할 점은 아래 if (_exitedValidatorsCounts[i] &lt; prevReportedExitedValidatorsCount)에서 유추할 수 있는 것처럼 _exitedValidatorsCounts 는 각 모듈당 누적된 탈퇴 validator의 수이다.</p><pre>function updateExitedValidatorsCountByStakingModule(<br>        uint256[] calldata _stakingModuleIds,<br>        uint256[] calldata _exitedValidatorsCounts<br>    )<br>        external<br>        onlyRole(REPORT_EXITED_VALIDATORS_ROLE)<br>        returns (uint256)<br>    {<br>        ...<br><br>        for (uint256 i = 0; i &lt; _stakingModuleIds.length; ) {<br>            uint256 stakingModuleId = _stakingModuleIds[i];<br>            StakingModule storage stakingModule = _getStakingModuleById(stakingModuleId);<br><br>            uint256 prevReportedExitedValidatorsCount = stakingModule.exitedValidatorsCount;<br>            if (_exitedValidatorsCounts[i] &lt; prevReportedExitedValidatorsCount) {<br>                revert ExitedValidatorsCountCannotDecrease();<br>            }<br><br>            ...<br><br>            newlyExitedValidatorsCount += _exitedValidatorsCounts[i] - prevReportedExitedValidatorsCount;<br><br>            ...<br>        }<br><br>        return newlyExitedValidatorsCount;<br>    }</pre><p>각 staking module별로 탈퇴한 validator가 업데이트되면, snaity checker를 호출하여, 하루당 탈퇴한 validator 비율이 limit을 넘지 않는지 확인한다.</p><h4>submitReportData — _handleConsensusReportData: withdrawalQueue</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tmcJbv_AOl_-OSkn5v6DlA.png" /></figure><pre>function onOracleReport(bool _isBunkerModeNow, uint256 _bunkerStartTimestamp, uint256 _currentReportTimestamp)<br>        external<br>    {<br>        _checkRole(ORACLE_ROLE, msg.sender);<br>        if (_bunkerStartTimestamp &gt;= block.timestamp) revert InvalidReportTimestamp();<br>        if (_currentReportTimestamp &gt;= block.timestamp) revert InvalidReportTimestamp();<br><br>        _setLastReportTimestamp(_currentReportTimestamp);<br><br>        bool isBunkerModeWasSetBefore = isBunkerModeActive();<br><br>        // on bunker mode state change<br>        if (_isBunkerModeNow != isBunkerModeWasSetBefore) {<br>            // write previous timestamp to enable bunker or max uint to disable<br>            if (_isBunkerModeNow) {<br>                BUNKER_MODE_SINCE_TIMESTAMP_POSITION.setStorageUint256(_bunkerStartTimestamp);<br><br>                emit BunkerModeEnabled(_bunkerStartTimestamp);<br>            } else {<br>                BUNKER_MODE_SINCE_TIMESTAMP_POSITION.setStorageUint256(BUNKER_MODE_DISABLED_TIMESTAMP);<br><br>                emit BunkerModeDisabled();<br>            }<br>        }<br>    }</pre><p>_handleConsensusReportData에서 위의 과정을 마무리한뒤 onOracleReport를 호출하여 WithdrawalQueue 컨트랙트에 레포트가 처리된 시점을 업데이트한다. 추가로, 벙커모드가 활성화되면, 벙커모드가 시작하는 시간도 업데이트한다. 이때 벙커모드의 시간은 prevRefSlot을 받으므로, 마지막 레포트가 제출된 시점을 벙커모드가 시작되는 시점으로 설정함을 알 수 있다.</p><h4>submitReportData — _handleConsensusReportData: handleOracleReport</h4><p>이전의 과정이 마무리되면, 본격적으로 제출한 오라클 레포트를 처리하는 작업을 시작한다. 아래는 handleOracleReport이 수행하는 핵심적인 과정이다. 이번 절은 각 스텝별로 코드를 살펴보도록 한다.</p><ol><li>현재 상태에 대해 스냅샷을 찍는다.</li><li>sanity checker에게 레포트 데이터 전달</li><li>출금 요청 처리를 위한 잠길 이더의 양과 태울 shares에 대한 사전 계산</li><li>출금 요청 확정</li><li>허용된 한도 내에서 초과 shares 소각</li><li>프로토콜 수수료 분배</li><li>토큰 리베이스</li><li>simulate된 share 비율에 대해 sanity check</li></ol><h4>스냅샷 촬영</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 1.<br>        // Take a snapshot of the current (pre-) state<br>        reportContext.preTotalPooledEther = _getTotalPooledEther();<br>        reportContext.preTotalShares = _getTotalShares();<br>        reportContext.preCLValidators = CL_VALIDATORS_POSITION.getStorageUint256();<br>        reportContext.preCLBalance = _processClStateUpdate(<br>            _reportedData.reportTimestamp,<br>            reportContext.preCLValidators,<br>            _reportedData.clValidators,<br>            _reportedData.postCLBalance<br>        );<br><br>...<br>}<br><br>function _getTotalPooledEther() internal view returns (uint256) {<br>        return _getBufferedEther()<br>            .add(CL_BALANCE_POSITION.getStorageUint256())<br>            .add(_getTransientBalance());<br>}<br><br>function _processClStateUpdate(<br>        uint256 _reportTimestamp,<br>        uint256 _preClValidators,<br>        uint256 _postClValidators,<br>        uint256 _postClBalance<br>    ) internal returns (uint256 preCLBalance) {<br>        uint256 depositedValidators = DEPOSITED_VALIDATORS_POSITION.getStorageUint256();<br>        require(_postClValidators &lt;= depositedValidators, &quot;REPORTED_MORE_DEPOSITED&quot;);<br>        require(_postClValidators &gt;= _preClValidators, &quot;REPORTED_LESS_VALIDATORS&quot;);<br><br>        if (_postClValidators &gt; _preClValidators) {<br>            CL_VALIDATORS_POSITION.setStorageUint256(_postClValidators);<br>        }<br><br>        uint256 appearedValidators = _postClValidators - _preClValidators;<br>        preCLBalance = CL_BALANCE_POSITION.getStorageUint256();<br>        // Take into account the balance of the newly appeared validators<br>        preCLBalance = preCLBalance.add(appearedValidators.mul(DEPOSIT_SIZE));<br><br>        // Save the current CL balance and validators to<br>        // calculate rewards on the next push<br>        CL_BALANCE_POSITION.setStorageUint256(_postClBalance);<br><br>        emit CLValidatorsUpdated(_reportTimestamp, _preClValidators, _postClValidators);<br>}</pre><p>스냅샷 촬영시에는 현재의 상태를 가져오는데, 이때 가져오는 상태로는 예치된 이더의 총량, 발행한 전체 shares, 컨센서스 레이어의 validator의 수, 컨센서스 레이어의 잔고를 가져온다. _getTotalPooledEther는 아직 stake되지 않은 이더, stake 과정에 있는 이더, 그리고 컨센서스 레이어에 있는 이더의 밸런스의 합을 반환한다. 그리고 발행한 총 stETH의 양과 validator의 수를 가져와서 컨센서스 레이어를 업데이트하기 위해 _processClStateUpdate를 호출한다. 이는 업데이트될 레포트의 validator 수와 balance를 받는다. 또한, 위의 함수를 보면, validator의 잔고는 validator 수 * 32 ether임을 알수 있다.</p><h4>Sanity Checker</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 2.<br>        // Pass the report data to sanity checker (reverts if malformed)<br>        _checkAccountingOracleReport(contracts, _reportedData, reportContext);<br><br>...<br>    }<br><br>//OracleReportSanityChecker.sol<br>function checkAccountingOracleReport(<br>        uint256 _timeElapsed,<br>        uint256 _preCLBalance,<br>        uint256 _postCLBalance,<br>        uint256 _withdrawalVaultBalance,<br>        uint256 _elRewardsVaultBalance,<br>        uint256 _sharesRequestedToBurn,<br>        uint256 _preCLValidators,<br>        uint256 _postCLValidators<br>    ) external view {<br>        LimitsList memory limitsList = _limits.unpack();<br><br>        address withdrawalVault = LIDO_LOCATOR.withdrawalVault();<br>        // 1. Withdrawals vault reported balance<br>        _checkWithdrawalVaultBalance(withdrawalVault.balance, _withdrawalVaultBalance);<br><br>        address elRewardsVault = LIDO_LOCATOR.elRewardsVault();<br>        // 2. EL rewards vault reported balance<br>        _checkELRewardsVaultBalance(elRewardsVault.balance, _elRewardsVaultBalance);<br><br>        // 3. Burn requests<br>        _checkSharesRequestedToBurn(_sharesRequestedToBurn);<br><br>        // 4. Consensus Layer one-off balance decrease<br>        _checkOneOffCLBalanceDecrease(limitsList, _preCLBalance, _postCLBalance + _withdrawalVaultBalance);<br><br>        // 5. Consensus Layer annual balances increase<br>        _checkAnnualBalancesIncrease(limitsList, _preCLBalance, _postCLBalance, _timeElapsed);<br><br>        // 6. Appeared validators increase<br>        if (_postCLValidators &gt; _preCLValidators) {<br>            _checkAppearedValidatorsChurnLimit(limitsList, (_postCLValidators - _preCLValidators), _timeElapsed);<br>        }<br>    }</pre><p>sanity checker에서 검증하는 항목은 아래와 같다.</p><ul><li>출금 vault의 잔고</li><li>실행 레이어의 보상 vault의 잔고</li><li>소각할 shares</li><li>한번에 큰 잔액이 감소하는지</li><li>마지막 레포트와 현재 레포트 시점 간 큰 잔액이 증가했는지</li></ul><p>위의 함수는 오라클에서 보고된 데이터의 유효성을 검사한다. 보고된 데이터가 현재 상태와 일치하는지 확인하고, 그렇지 않은 경우에는 에러를 발생시킨다.</p><h4>인출을 위해 잠긴 이더와 소각된 share의 사전 계산과 소각 요청</h4><pre>    function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 3.<br>        // Pre-calculate the ether to lock for withdrawal queue and shares to be burnt<br>        // due to withdrawal requests to finalize<br>        if (_reportedData.withdrawalFinalizationBatches.length != 0) {<br>            (<br>                reportContext.etherToLockOnWithdrawalQueue,<br>                reportContext.sharesToBurnFromWithdrawalQueue<br>            ) = _calculateWithdrawals(contracts, _reportedData);<br><br>            if (reportContext.sharesToBurnFromWithdrawalQueue &gt; 0) {<br>                IBurner(contracts.burner).requestBurnShares(<br>                    contracts.withdrawalQueue,<br>                    reportContext.sharesToBurnFromWithdrawalQueue<br>                );<br>            }<br>        }<br><br>...<br>}<br><br>function _calculateWithdrawals(<br>        OracleReportContracts memory _contracts,<br>        OracleReportedData memory _reportedData<br>    ) internal view returns (<br>        uint256 etherToLock, uint256 sharesToBurn<br>    ) {<br>        IWithdrawalQueue withdrawalQueue = IWithdrawalQueue(_contracts.withdrawalQueue);<br><br>        if (!withdrawalQueue.isPaused()) {<br>            IOracleReportSanityChecker(_contracts.oracleReportSanityChecker).checkWithdrawalQueueOracleReport(<br>                _reportedData.withdrawalFinalizationBatches[_reportedData.withdrawalFinalizationBatches.length - 1],<br>                _reportedData.reportTimestamp<br>            );<br><br>            (etherToLock, sharesToBurn) = withdrawalQueue.prefinalize(<br>                _reportedData.withdrawalFinalizationBatches,<br>                _reportedData.simulatedShareRate<br>            );<br>        }<br>}</pre><p>먼저, 요청된 출금에 대해서 sanity checker를 통해 유효성을 검사하는데, 이때의 시행되는 유효성 검사는 출금 요청들이 유효한 시간 내에 있는지 확인을 한다. 레포트가 제출된 시간이 출금 요청된 시간과 오라클 레포트 시점까지 필요한 최소시간의 합보다 커야한다. 검증이 마무리되면, prefinalize를 호출하여 출금할 eth의 양과 소각해야할 share를 계산한다. 마지막으로, requestBurnShares를 호출하여 계산된 값을 바탕으로 소각요청을 보낸다.</p><h4>토큰 리베이스와 관련된 값 검증</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 4.<br>        // Pass the accounting values to sanity checker to smoothen positive token rebase<br><br>        uint256 withdrawals;<br>        uint256 elRewards;<br>        (<br>            withdrawals, elRewards, reportContext.simulatedSharesToBurn, reportContext.sharesToBurn<br>        ) = IOracleReportSanityChecker(contracts.oracleReportSanityChecker).smoothenTokenRebase(<br>            reportContext.preTotalPooledEther,<br>            reportContext.preTotalShares,<br>            reportContext.preCLBalance,<br>            _reportedData.postCLBalance,<br>            _reportedData.withdrawalVaultBalance,<br>            _reportedData.elRewardsVaultBalance,<br>            _reportedData.sharesRequestedToBurn,<br>            reportContext.etherToLockOnWithdrawalQueue,<br>            reportContext.sharesToBurnFromWithdrawalQueue<br>        );<br><br>...<br>    }<br><br>function smoothenTokenRebase(<br>        uint256 _preTotalPooledEther,<br>        uint256 _preTotalShares,<br>        uint256 _preCLBalance,<br>        uint256 _postCLBalance,<br>        uint256 _withdrawalVaultBalance,<br>        uint256 _elRewardsVaultBalance,<br>        uint256 _sharesRequestedToBurn,<br>        uint256 _etherToLockForWithdrawals,<br>        uint256 _newSharesToBurnForWithdrawals<br>    ) external view returns (<br>        uint256 withdrawals,<br>        uint256 elRewards,<br>        uint256 simulatedSharesToBurn,<br>        uint256 sharesToBurn<br>    ) {<br>        TokenRebaseLimiterData memory tokenRebaseLimiter = PositiveTokenRebaseLimiter.initLimiterState(<br>            getMaxPositiveTokenRebase(),<br>            _preTotalPooledEther,<br>            _preTotalShares<br>        );<br><br>        if (_postCLBalance &lt; _preCLBalance) {<br>            tokenRebaseLimiter.decreaseEther(_preCLBalance - _postCLBalance);<br>        } else {<br>            tokenRebaseLimiter.increaseEther(_postCLBalance - _preCLBalance);<br>        }<br><br>        withdrawals = tokenRebaseLimiter.increaseEther(_withdrawalVaultBalance);<br>        elRewards = tokenRebaseLimiter.increaseEther(_elRewardsVaultBalance);<br><br>        // determining the shares to burn limit that would have been<br>        // if no withdrawals finalized during the report<br>        // it&#39;s used to check later the provided `simulatedShareRate` value<br>        // after the off-chain calculation via `eth_call` of `Lido.handleOracleReport()`<br>        // see also step 9 of the `Lido._handleOracleReport()`<br>        simulatedSharesToBurn = Math256.min(tokenRebaseLimiter.getSharesToBurnLimit(), _sharesRequestedToBurn);<br><br>        // remove ether to lock for withdrawals from total pooled ether<br>        tokenRebaseLimiter.decreaseEther(_etherToLockForWithdrawals);<br>        // re-evaluate shares to burn after TVL was updated due to withdrawals finalization<br>        sharesToBurn = Math256.min(<br>            tokenRebaseLimiter.getSharesToBurnLimit(),<br>            _newSharesToBurnForWithdrawals + _sharesRequestedToBurn<br>        );<br>    }</pre><p>sanity checker에서는 increasEther 혹은 decreaseEther를 호출 하면서 이전 오라클 레포트 시점에서 현재 오라클 레포트 시점까지 TokenRebaseLimiter를 호출하여, 이더의 양이 적절히 증가 혹은 감소했는지 검사한다. TokenRebaseLimiter의 현재 ether의 양을 업데이트하고, 이전에 예치된 ether의 양에 비해 증가했는지, 증가했다면 얼마나 증가했는지를 반환한다. 한가지 짚고 넘어가는 부분은 예치되는 ether는 TokenRebaseLimiter에 허용된 최대 예치 ether를 넘을 순 없다. 그리고 소각할 shares와 시뮬레이션 돌린 shares를 계산한다.</p><h4>출금 요청 확정</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 5.<br>        // Invoke finalization of the withdrawal requests (send ether to withdrawal queue, assign shares to be burnt)<br>        _collectRewardsAndProcessWithdrawals(<br>            contracts,<br>            withdrawals,<br>            elRewards,<br>            _reportedData.withdrawalFinalizationBatches,<br>            _reportedData.simulatedShareRate,<br>            reportContext.etherToLockOnWithdrawalQueue<br>        );<br><br>        emit ETHDistributed(<br>            _reportedData.reportTimestamp,<br>            reportContext.preCLBalance,<br>            _reportedData.postCLBalance,<br>            withdrawals,<br>            elRewards,<br>            _getBufferedEther()<br>        );<br><br>...<br>    }<br><br>function _collectRewardsAndProcessWithdrawals(<br>        OracleReportContracts memory _contracts,<br>        uint256 _withdrawalsToWithdraw,<br>        uint256 _elRewardsToWithdraw,<br>        uint256[] _withdrawalFinalizationBatches,<br>        uint256 _simulatedShareRate,<br>        uint256 _etherToLockOnWithdrawalQueue<br>    ) internal {<br>        // withdraw execution layer rewards and put them to the buffer<br>        if (_elRewardsToWithdraw &gt; 0) {<br>            ILidoExecutionLayerRewardsVault(_contracts.elRewardsVault).withdrawRewards(_elRewardsToWithdraw);<br>        }<br><br>        // withdraw withdrawals and put them to the buffer<br>        if (_withdrawalsToWithdraw &gt; 0) {<br>            IWithdrawalVault(_contracts.withdrawalVault).withdrawWithdrawals(_withdrawalsToWithdraw);<br>        }<br><br>        // finalize withdrawals (send ether, assign shares for burning)<br>        if (_etherToLockOnWithdrawalQueue &gt; 0) {<br>            IWithdrawalQueue withdrawalQueue = IWithdrawalQueue(_contracts.withdrawalQueue);<br>            withdrawalQueue.finalize.value(_etherToLockOnWithdrawalQueue)(<br>                _withdrawalFinalizationBatches[_withdrawalFinalizationBatches.length - 1],<br>                _simulatedShareRate<br>            );<br>        }<br><br>        uint256 postBufferedEther = _getBufferedEther()<br>            .add(_elRewardsToWithdraw) // Collected from ELVault<br>            .add(_withdrawalsToWithdraw) // Collected from WithdrawalVault<br>            .sub(_etherToLockOnWithdrawalQueue); // Sent to WithdrawalQueue<br><br>        _setBufferedEther(postBufferedEther);<br>    }</pre><p>확정된 요청 출금을 수행하기 위해 _elRewardsToWithdraw, _withdrawalsToWithdraw값을 각 vault에서 가져온다. 다음으로, 출금 큐의 총 이더의 양을 확정처리 한다. 다음으로, 버퍼의 이더양을 업데이트하여 마무리한다.</p><h4>shares 소각</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 6.<br>        // Burn the previously requested shares<br>        if (reportContext.sharesToBurn &gt; 0) {<br>            IBurner(contracts.burner).commitSharesToBurn(reportContext.sharesToBurn);<br>            _burnShares(contracts.burner, reportContext.sharesToBurn);<br>        }<br><br>...<br>    }<br><br>//Burner.sol<br>function commitSharesToBurn(uint256 _sharesToBurn) external virtual override {<br>        if (msg.sender != STETH) revert AppAuthLidoFailed();<br><br>        if (_sharesToBurn == 0) {<br>            return;<br>        }<br><br>        uint256 memCoverSharesBurnRequested = coverSharesBurnRequested;<br>        uint256 memNonCoverSharesBurnRequested = nonCoverSharesBurnRequested;<br><br>        uint256 burnAmount = memCoverSharesBurnRequested + memNonCoverSharesBurnRequested;<br><br>        if (_sharesToBurn &gt; burnAmount) {<br>            revert BurnAmountExceedsActual(_sharesToBurn, burnAmount);<br>        }<br><br>        uint256 sharesToBurnNow;<br>        if (memCoverSharesBurnRequested &gt; 0) {<br>            uint256 sharesToBurnNowForCover = Math.min(_sharesToBurn, memCoverSharesBurnRequested);<br><br>            totalCoverSharesBurnt += sharesToBurnNowForCover;<br>            uint256 stETHToBurnNowForCover = IStETH(STETH).getPooledEthByShares(sharesToBurnNowForCover);<br>            emit StETHBurnt(true /* isCover */, stETHToBurnNowForCover, sharesToBurnNowForCover);<br><br>            coverSharesBurnRequested -= sharesToBurnNowForCover;<br>            sharesToBurnNow += sharesToBurnNowForCover;<br>        }<br>        if (memNonCoverSharesBurnRequested &gt; 0 &amp;&amp; sharesToBurnNow &lt; _sharesToBurn) {<br>            uint256 sharesToBurnNowForNonCover = Math.min(<br>                _sharesToBurn - sharesToBurnNow,<br>                memNonCoverSharesBurnRequested<br>            );<br><br>            totalNonCoverSharesBurnt += sharesToBurnNowForNonCover;<br>            uint256 stETHToBurnNowForNonCover = IStETH(STETH).getPooledEthByShares(sharesToBurnNowForNonCover);<br>            emit StETHBurnt(false /* isCover */, stETHToBurnNowForNonCover, sharesToBurnNowForNonCover);<br><br>            nonCoverSharesBurnRequested -= sharesToBurnNowForNonCover;<br>            sharesToBurnNow += sharesToBurnNowForNonCover;<br>        }<br>        assert(sharesToBurnNow == _sharesToBurn);<br>    }</pre><p>출금 요청 확정처리한 후에, Burner를 호출하여 소각하고자 하는 shares에 대해 이벤트 로그를 남긴다. 이전 단계에 requestBurn을 통해 갱신된 coverSharesBurnRequested와 nonCoverSharesBurnRequested을 가져온다. 소각하고자 하는 양은 컨트랙트에 기록된 요청된 양과 정확히 일치해야한다. 소각해야할 양에 대한 검증이 마무리되면, _burnShares를 호출하여 소각을 진행한다.</p><h4>프로토콜 수수료 분배와 LIP-12</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 7.<br>        // Distribute protocol fee (treasury &amp; node operators)<br>        reportContext.sharesMintedAsFees = _processRewards(<br>            reportContext,<br>            _reportedData.postCLBalance,<br>            withdrawals,<br>            elRewards<br>        );<br><br>...<br>    }<br><br>function _distributeFee(<br>        uint256 _preTotalPooledEther,<br>        uint256 _preTotalShares,<br>        uint256 _totalRewards<br>    ) internal returns (uint256 sharesMintedAsFees) {<br>        // We need to take a defined percentage of the reported reward as a fee, and we do<br>        // this by minting new token shares and assigning them to the fee recipients (see<br>        // StETH docs for the explanation of the shares mechanics). The staking rewards fee<br>        // is defined in basis points (1 basis point is equal to 0.01%, 10000 (TOTAL_BASIS_POINTS) is 100%).<br>        //<br>        // Since we are increasing totalPooledEther by _totalRewards (totalPooledEtherWithRewards),<br>        // the combined cost of all holders&#39; shares has became _totalRewards StETH tokens more,<br>        // effectively splitting the reward between each token holder proportionally to their token share.<br>        //<br>        // Now we want to mint new shares to the fee recipient, so that the total cost of the<br>        // newly-minted shares exactly corresponds to the fee taken:<br>        //<br>        // totalPooledEtherWithRewards = _preTotalPooledEther + _totalRewards<br>        // shares2mint * newShareCost = (_totalRewards * totalFee) / PRECISION_POINTS<br>        // newShareCost = totalPooledEtherWithRewards / (_preTotalShares + shares2mint)<br>        //<br>        // which follows to:<br>        //<br>        //                        _totalRewards * totalFee * _preTotalShares<br>        // shares2mint = --------------------------------------------------------------<br>        //                 (totalPooledEtherWithRewards * PRECISION_POINTS) - (_totalRewards * totalFee)<br>        //<br>        // The effect is that the given percentage of the reward goes to the fee recipient, and<br>        // the rest of the reward is distributed between token holders proportionally to their<br>        // token shares.<br><br>        (<br>            StakingRewardsDistribution memory rewardsDistribution,<br>            IStakingRouter router<br>        ) = _getStakingRewardsDistribution();<br><br>        if (rewardsDistribution.totalFee &gt; 0) {<br>            uint256 totalPooledEtherWithRewards = _preTotalPooledEther.add(_totalRewards);<br><br>            sharesMintedAsFees =<br>                _totalRewards.mul(rewardsDistribution.totalFee).mul(_preTotalShares).div(<br>                    totalPooledEtherWithRewards.mul(<br>                        rewardsDistribution.precisionPoints<br>                    ).sub(_totalRewards.mul(rewardsDistribution.totalFee))<br>                );<br><br>            _mintShares(address(this), sharesMintedAsFees);<br><br>            (uint256[] memory moduleRewards, uint256 totalModuleRewards) =<br>                _transferModuleRewards(<br>                    rewardsDistribution.recipients,<br>                    rewardsDistribution.modulesFees,<br>                    rewardsDistribution.totalFee,<br>                    sharesMintedAsFees<br>                );<br><br>            _transferTreasuryRewards(sharesMintedAsFees.sub(totalModuleRewards));<br><br>            router.reportRewardsMinted(<br>                rewardsDistribution.moduleIds,<br>                moduleRewards<br>            );<br>        }<br>    }</pre><p>다음으로, 프로토콜 수수료를 treasury와 노드들에게 분배하는 절차를 가진다. 프로토콜 수수료 분배를 알기 위해서는 다음의 LIP-12[3]를 알 필요가 있다. LIP-12는 이더리움 merge이후 validator가 얻는 수수료는 거래 수수료와 실행 레이어에서 얻는 MEV이다. LIP-12는 이 수익을 어떻게 처리할지에 대한 논의인데, 실행 레이어에서의 보상을 다시 스테이킹하고, 10% 프로토콜 수수료만 stETH로 발행하도록 하자는 논의이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vIyswQ3Wx0dGypHwuk5w7w.png" /></figure><p>_processRewards에서는 레포트 제출 시점 이전과 이후의 컨센서스 레이어의 잔고의 차익을 컨세서스 레이어의 리워드(consensusLayerRewards)로 본다. 그리고 consensusLayerRewards와 _withdrawnElRewards의 합이 분배대상이 되는 수수료가 된다. 즉, 위 그림의 collected tx fees + extracted MEV가 consensusLayerRewards + _withdrawnElRewards가 된다.</p><p>_distributeFee를 보면 Fee로 분배할 stETH(sharesMintedAsFees)를 아래의 식으로 계산하고, 등록된 모듈에 moduleFee만큼 전송한다. 마지막으로, 남은 stETH는 treasury로 전송한다.</p><pre>totalPooledEtherWithRewards = _preTotalPooledEther + _totalRewards<br>shares2mint * newShareCost = (_totalRewards * totalFee) / PRECISION_POINTS<br>newShareCost = totalPooledEtherWithRewards / (_preTotalShares + shares2mint)<br><br>                        _totalRewards * totalFee * _preTotalShares<br> shares2mint = --------------------------------------------------------------<br>                 (totalPooledEtherWithRewards * PRECISION_POINTS) - (_totalRewards * totalFee)</pre><h4>토큰 리베이스와 Sanity Check</h4><pre>function _handleOracleReport(OracleReportedData memory _reportedData) internal returns (uint256[4]) {<br>...<br><br>        // Step 8.<br>        // Complete token rebase by informing observers (emit an event and call the external receivers if any)<br>        (<br>            uint256 postTotalShares,<br>            uint256 postTotalPooledEther<br>        ) = _completeTokenRebase(<br>            _reportedData,<br>            reportContext,<br>            IPostTokenRebaseReceiver(contracts.postTokenRebaseReceiver)<br>        );<br><br>        // Step 9. Sanity check for the provided simulated share rate<br>        if (_reportedData.withdrawalFinalizationBatches.length != 0) {<br>            IOracleReportSanityChecker(contracts.oracleReportSanityChecker).checkSimulatedShareRate(<br>                postTotalPooledEther,<br>                postTotalShares,<br>                reportContext.etherToLockOnWithdrawalQueue,<br>                reportContext.sharesToBurn.sub(reportContext.simulatedSharesToBurn),<br>                _reportedData.simulatedShareRate<br>            );<br>        }<br><br>        return [postTotalPooledEther, postTotalShares, withdrawals, elRewards];<br>    }</pre><p>마지막으로, 리베이스된 토큰에 대해서 업데이트를 진행하고, Sanity Check를 진행한다. 리베이스된 토큰에 대해서 업데이트는 Oracle에 레포트가 적용된 후의 TotalShares, TotalPooledEther, Fee로 민트된 stETH의 양(sharesMintedAsFees)를 업데이트한다. sanity checker에서는 simulate된 share가 limit을 넘는지 확인한다.</p><h3>Reference</h3><ol><li><a href="https://docs.lido.fi/contracts/hash-consensus#report-processor-ireportasyncprocessor">https://docs.lido.fi/contracts/hash-consensus#report-processor-ireportasyncprocessor</a></li><li><a href="https://docs.lido.fi/contracts/accounting-oracle#report-processing">https://docs.lido.fi/contracts/accounting-oracle#report-processing</a></li><li><a href="https://research.lido.fi/t/lip-12-on-chain-part-of-the-rewards-distribution-after-the-merge/1625">https://research.lido.fi/t/lip-12-on-chain-part-of-the-rewards-distribution-after-the-merge/1625</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a1e9963df50" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>