<?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 choi_eth on Medium]]></title>
        <description><![CDATA[Stories by choi_eth on Medium]]></description>
        <link>https://medium.com/@choi_eth?source=rss-4858a4819f54------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sHRUvPX2p7vUyJyh1Ao_rA.jpeg</url>
            <title>Stories by choi_eth on Medium</title>
            <link>https://medium.com/@choi_eth?source=rss-4858a4819f54------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:25:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@choi_eth/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[아비트럼 트랜잭션 수수료 모델 톺아보기 (하)]]></title>
            <link>https://medium.com/@choi_eth/%EC%95%84%EB%B9%84%ED%8A%B8%EB%9F%BC-%ED%8A%B8%EB%9E%9C%EC%9E%AD%EC%85%98-%EC%88%98%EC%88%98%EB%A3%8C-%EB%AA%A8%EB%8D%B8-%ED%86%BA%EC%95%84%EB%B3%B4%EA%B8%B0-%ED%95%98-3b47b4a7f77a?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b47b4a7f77a</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[arbitrum]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Wed, 23 Jul 2025 02:33:52 GMT</pubDate>
            <atom:updated>2025-07-23T02:34:17.915Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>본 아티클은 아비트럼 프로토콜에서 설계한 트랜잭션 수수료 모델에 대해 기술적 내용을 다루고 있습니다. 해당 글에 포함된 내용은 아비트럼에 대한 투자 조언으로 의도한 것이 아니며, 객관적인 투자 조언으로 전달 될 의도가 없음을 밝힙니다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uq9dKXpfMxB5zwLFm7PiHA.png" /></figure><h3>Author</h3><p>Writter by 최원혁 (<a href="https://x.com/born_to_dev1001">@choi</a> )</p><h3>Abstract</h3><p>이전 <a href="https://medium.com/@choi_eth/%EC%95%84%EB%B9%84%ED%8A%B8%EB%9F%BC-%ED%8A%B8%EB%9E%9C%EC%9E%AD%EC%85%98-%EC%88%98%EC%88%98%EB%A3%8C-%EB%AA%A8%EB%8D%B8-%ED%86%BA%EC%95%84%EB%B3%B4%EA%B8%B0-%EC%83%81-f62901204975">시리즈(상)</a>에서는 아비트럼이 체인의 특성에 맞춰 개발된 <strong>독립적인 수수료 모델</strong>을 통해 트랜잭션 수수료를 결정한다는 내용을 다룬 바 있다. 이는 크게 <strong>Poster Fee</strong>와 <strong>Network Fee</strong> 두 가지 요소에 의해 구성되며, 트랜잭션의 최종 수수료는 아래와 같은 수식으로 계산된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rvxh-ZlNeqiUXyq0TPeXuw.png" /></figure><p>상편에서는 <strong>Poster Fee</strong>와 이와 밀접한 관련이 있는 <strong>L1 Gas Used</strong>가 어떻게 산정되는지에 대해 집중적으로 설명하였다. 이번 편(하)에서는 <strong>Network Fee</strong>의 계산 방식과 더불어, 아비트럼 네트워크에서 <strong>L2 Gas Price가 어떻게 결정되는지</strong>에 대해 보다 깊이 있게 살펴보고자 한다.</p><h3>Network Fee</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zt0G3-E-ygoCPTTP75tUZg.png" /></figure><p>아비트럼의 <strong>Network Fee</strong>는 순수하게 트랜잭션을 실행하는 데 필요한 수수료를 의미한다. 이더리움에서는 트랜잭션 실행 과정에서 EVM에 의해 결정된 가스 사용량(Gas Used)에 현재 가스 가격(Gas Price)을 곱하여 수수료가 계산된다. 아비트럼 또한 EVM 실행 레이어를 그대로 포크하여 사용하는 Layer2 체인이므로, 트랜잭션 실행에 필요한 가스량은 이더리움과 동일한 방식으로 측정되며, 이를 <strong>L2 Gas Used</strong>라고 정의한다.</p><p><strong>L2 Gas Price</strong>는 이더리움의 네트워크 상태와는 무관하게, 아비트럼이 자체적으로 설계한 알고리즘과 프로토콜을 통해 <strong>네트워크 혼잡도, 처리량 등을 고려하여 동적으로 결정</strong>된다.</p><h3>L2 Gas Metering and Pricing</h3><p><strong>L2 Gas Price</strong>는 아비트럼 네트워크에서의 트랜잭션 수수료 계산에 사용되는 가스 가격을 의미한다. 이는 이더리움의 <strong>EIP-1559</strong> 메커니즘과는 다르게, 아비트럼에서 자체적으로 설계한 알고리즘을 기반으로 결정된다. 해당 알고리즘은 <strong>네트워크의 혼잡도에 따라 가스 가격이 동적으로 조정</strong>되도록 설계되어 있다. 네트워크가 혼잡한 경우에는 가스 가격을 상승시켜 트랜잭션 수요를 조절하고, 이를 통해 자연스럽게 혼잡도를 완화하는 구조를 가진다.</p><p>또한, 아비트럼은 <strong>최소 가스 가격(minimum base fee)</strong> 이라는 하한선을 설정하고 있어, 네트워크가 비혼잡한 상황에서도 가스 가격이 <strong>0.01 Gwei 이하로는 하락하지 않도록 제한</strong>되어 있다.</p><h3>SpeedLimit &amp; backlog</h3><p>아비트럼에는 시스템 상에 <strong>SpeedLimit</strong>과 <strong>backlog</strong> 두 변수가 설정되어 있는데, 이는 가스 가격을 결정하는데 중요한 역할이 된다.</p><p><strong>SpeedLimit</strong>는 네트워크가 1초 동안 처리할 수 있는 <strong><em>“이상적인 가스량”</em></strong>을 의미한다. 아비트럼은 0.25초마다 1개의 블록이 생성되도록 설계되어 있어, 1초에 총 4개의 블록이 생성된다. 따라서 SpeedLimit는 1초 동안 생성되는 4개의 블록이 <strong>가장 이상적인 상태에서 처리할 수 있는 총 가스량</strong>을 나타낸다.</p><blockquote>주의할 점은, SpeedLimit는 블록당 최대 가스 허용량(max gas limit)과는 다른 개념이다. 후자는 블록 1개 단위의 Gas Limit이라면, SpeedLimit는 네트워크가 안정적으로 감당 가능한 ‘이상적’ 처리 용량을 정의한다.</blockquote><p><strong>backlog</strong>는 네트워크 상에서 실제로 사용된 가스량이 시간 단위로 누적된 값을 의미한다. 예를 들어, 1초 동안 생성된 4개의 블록에서 각각 1,000 gas가 사용되었다면, backlog에는 총 4,000 gas가 기록된다. 블록이 생성되면서 각각 1000 gas를 사용했으면 backlog는 시스템상으로 4000이 기록되어 있을 것이다.</p><p>아비트럼은 블록이 생성될 때마다 해당 블록에서 사용된 가스량을 backlog에 <strong>누적</strong>하며, 동시에 매 1초마다 backlog에서 <strong>SpeedLimit 값을 차감</strong>한다. 이를 통해 backlog는 실시간으로 증가 및 감소를 반복하며, 네트워크의 트래픽 상태를 반영하는 동적 지표로 작동한다.</p><h4>Example</h4><p>현재 <a href="https://sepolia.arbiscan.io/address/0x000000000000000000000000000000000000006C#readContract#F3">아비트럼의 SpeedLimit는 7,000,000</a>으로 설정되어 있다. 이를 기반으로 예를 들어 보면 다음과 같다:</p><p><strong>Case1</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PSdFdOJhHupRiNHPSD2HVA.png" /></figure><p>매 블록마다 약 100만의 Gas가 사용됬다고 가정해보자. 4개의 블록이 생성된 시점에서 backlog에는 400만이 누적되어 있지만, SpeedLimit만큼 빼면 backlog는 0이 된다. ( backlog는 uint 타입이기에 음수가 없다 )</p><p><strong>Case2</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*igJuRyIqueniUfrz0npM7w.png" /></figure><p>이번에는 매 블록마다 약 500만의 Gas가 사용됬다고 가정해보자. 4개의 블록이 생성된 시점에서 backlog에는 2000만이 누적되어 있지만, SpeedLimit만큼 빼면 backlog는 1300만이 된다.</p><p>이러한 프로토콜 과정에서 아비트럼은 블록이 생성된 시점에 누적된 backlog가 허용 오차를 넘어갈 경우, 가스 가격(L2 Gas Price)를 상승되도록 설계하였다. 아비트럼의 경우 허용 오차가 SpeedLimit * 10 = 70,000,000으로 설정되어 있다.</p><h3>Exponential Pricing Model (지수 가격 모델)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Ay0iaOqmV_brc4tD77e-g.png" /></figure><p>아비트럼의 가스 가격은 위와 같은 <strong>지수 가격 모델(Exponential Pricing Model)</strong> 에 기반하여 계산된다. 수식에는 여러 동적인 계수를 통해 <strong>지수적으로 가스 가격이 증가</strong>하도록 설계되어 있다. 지금까지 설명한 변수를 바탕으로 위에서 언급한 지수 가격 모델의 수식을 정의해보자.</p><ul><li>F₀ : 최소 가스 가격 ( =0.01 gwei )</li><li>B : 현재 누적된 backlog</li><li>B₀ : backlog 허용 오차 ( =70,000,000 )</li><li>β : ( ≈1/102 )</li><li>max (a, b) : a와 b 중 큰 숫자 return</li></ul><p>결과적으로 L2 Gas Price는 지수(e)의 계수가 어떤 값인지에 따라 최소 가스 가격과 곱하여 결정된다. 그리고 max(a,b)는 a와 b중 큰 숫자를 반환하는 조건 수식이다. 때문에 2가지 Case로 구분할 수 있다.</p><p><strong>Case1 :</strong> 누적된 backlog(B)가 허용 오차(B₀)를 초과하지 않은 경우</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/592/1*QnKhDq7Icpqzuv2vmkhGDw.png" /></figure><p>누적된 backlog(B)가 허용 오차(B₀)를 초과하지 않으면, B — B₀는 음수가 되어 최종적으로 0이 된다. (backlog의 타입이 uint이기 때문에 음수는 0이 된다.) 이 경우 max(a, b)는 0을 반환하며, 지수의 계수는 0이 되어 지수는 1이 된다. 최소 가스 가격(F₀)과 1을 곱하면 결국 L2 Gas Price는 0.01 Gwei가 된다.</p><p><strong>Case2 :</strong> 누적된 backlog(B)가 허용 오차(B₀)를 초과하는 경우</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*RnVuPSw3BKHNk0-RZIU7pQ.png" /></figure><p>누적된 backlog(B)가 허용 오차(B₀)를 초과하면, B — B₀는 0이 아닌 어떤 양수(+)의 값이 된다. 이 값에 β를 곱한 값이 지수의 계수가 되며, 지수 함수의 값이 결정된다. 아비트럼 <a href="https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf">White Paper</a>에 따르면, 해당 값과 최소 가스 가격을 곱할 경우 L2 Gas Price는 최소 가스 가격에서 약 9/8만큼 점진적으로 증가한다고 한다.</p><p>두 경우를 정리하자면, 1초 동안 생성되는 4개의 블록에서 누적된 backlog가 허용 오차를 초과할 경우, 가스 가격은 약 9/8씩 점진적으로 증가하도록 설계된 알고리즘이라고 할 수 있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1uBIKXo95UmP1njFnWIGHA.png" /><figcaption><a href="https://dune.com/queries/2684337/4463878?Blockchain_e15077=Arbitrum+One">https://dune.com/queries/2684337/4463878?Blockchain_e15077=Arbitrum+One</a></figcaption></figure><p>아티클을 작성하는 기준으로 7월5일부터 약 2주간의 가스 가격을 조회해보면, 네트워크가 혼잡할때 최대 0.8 gwei까지 올랐다가, 다시 최소 가스 가격( 0.01 gwei )으로 돌아오는것을 확인할 수 있다. 이러한 지수 모델 알고리즘으로 아비트럼은 단순한 고정 요율이 아닌 <strong>실시간 네트워크 상황에 반응하는 합리적인 수수료 모델</strong>을 구현하고 있으며, 네트워크의 안정성과 예측 가능성을 동시에 확보할 수 있도록 유도하고 있다.</p><h3>마치며</h3><p>지금까지 상·하 두 편에 걸쳐 아비트럼의 수수료 모델에 대해 심도 있게 살펴보았다. 아비트럼은 이더리움 기반의 Layer2 체인으로, 보다 저렴한 수수료와 쾌적한 환경에서 블록체인 인프라를 제공하는 것을 목표로 하고 있다. 이를 위해 자체적인 수수료 알고리즘을 개발하여, 사용자에게 합리적인 비용이 청구되도록 설계되어 있는 것이 특징이다.</p><p>또한 아비트럼은 Orbit SDK를 통해 Layer3 체인 구축을 위한 개발 도구를 함께 제공하고 있다. 필자 역시 Orbit SDK를 활용하여 EVM 기반의 Layer3 체인을 구축한 경험이 있으며, 이 과정에서 아비트럼 수수료 모델 전반에 대한 R&amp;D를 진행한 바 있다. 본 아티클은 해당 경험을 바탕으로 작성된 것으로, Orbit SDK를 활용해 Layer3 체인을 구축하거나 아비트럼 위에서 DApp 서비스를 기획 중인 개발자에게 실질적인 도움이 되기를 바란다.</p><h3>Referencec</h3><ul><li><strong>[Offchain Labs]</strong> <strong>Understanding Arbitrum: 2-Dimensional Fees :</strong> <a href="https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9">https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9</a></li><li><strong>[Arbitrum Docs] Gas and Fees :</strong> <a href="https://docs.arbitrum.io/how-arbitrum-works/gas-fees">https://docs.arbitrum.io/how-arbitrum-works/gas-fees</a></li><li><strong>[Arbitrum Docs] gas-and-fees(inside-arbitrum-nitro)</strong> : <a href="https://docs.arbitrum.io/how-arbitrum-works/inside-arbitrum-nitro#gas-and-fees">https://docs.arbitrum.io/how-arbitrum-works/inside-arbitrum-nitro#gas-and-fees</a></li><li><strong>[Offchain Labs Github] Nitro :</strong> <a href="https://github.com/OffchainLabs/nitro">https://github.com/OffchainLabs/nitro</a></li><li><strong>[Offchain Labs Github] Nitro-whitepaper :</strong> <a href="https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf">https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf</a></li><li><strong>[Dune] :</strong> <a href="https://dune.com/queries/2684337/4463878?Blockchain_e15077=Arbitrum+One">https://dune.com/queries/2684337/4463878?Blockchain_e15077=Arbitrum+One</a></li><li><strong>[Arbitrum Whitepaper]</strong> : <a href="https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf">https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b47b4a7f77a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[아비트럼 트랜잭션 수수료 모델 톺아보기 (상)]]></title>
            <link>https://medium.com/@choi_eth/%EC%95%84%EB%B9%84%ED%8A%B8%EB%9F%BC-%ED%8A%B8%EB%9E%9C%EC%9E%AD%EC%85%98-%EC%88%98%EC%88%98%EB%A3%8C-%EB%AA%A8%EB%8D%B8-%ED%86%BA%EC%95%84%EB%B3%B4%EA%B8%B0-%EC%83%81-f62901204975?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/f62901204975</guid>
            <category><![CDATA[arbitrum]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Wed, 18 Sep 2024 03:19:50 GMT</pubDate>
            <atom:updated>2025-07-23T02:35:48.420Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>본 아티클은 아비트럼 프로토콜에서 설계한 트랜잭션 수수료 모델에 대해 기술적 내용을 다루고 있습니다. 해당 글에 포함된 내용은 아비트럼에 대한 투자 조언으로 의도한 것이 아니며, 객관적인 투자 조언으로 전달 될 의도가 없음을 밝힙니다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uq9dKXpfMxB5zwLFm7PiHA.png" /></figure><h3>Author</h3><p>Writer by <a href="https://x.com/Choi__eth">@choi_eth</a></p><h3>Abstract</h3><p>아비트럼은 EVM(Ethereum Virtual Machine) 기반의 Layer 2 체인으로, 이더리움에서 수행되는 Dapp, Smart Contract 등의 모든 작업을 동일하게 처리할 수 있는 환경을 제공한다. 하지만 이더리움이 EIP-1559 수수료 모델을 사용하는 것과는 다르게, 아비트럼은 체인의 특성에 맞춰 개발된 독립적인 수수료 모델을 통해 트랜잭션 수수료를 결정한다. 이 아티클에서는 아비트럼의 수수료 모델을 통해 어떻게 사용자들의 트랜잭션 수수료가 결정되는지 다룰 예정이다.</p><blockquote>‘본 아티클은 아비트럼, 롤업(Rollup), 그리고 레이어2에 대한 기본 지식이 필요하다는 점 참고하시기 바란다.’</blockquote><h3>Intro : 아비트럼 트랜잭션 수수료</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mNZxkKDw-TF4G1PuxgOcfg.png" /><figcaption>[그림 1] <a href="https://arbiscan.io/tx/0x0d3fea2d4ed943c473e17a3ecd3b51c35cadaef30f1275a01199a9831968b77e#txninfo">https://arbiscan.io/tx/0x0d3fea2d4ed943c473e17a3ecd3b51c35cadaef30f1275a01199a9831968b77e#txninfo</a></figcaption></figure><p>아비트럼에서 트랜잭션을 조회해 보면, <strong>Network Fee</strong>와 <strong>Poster Fee</strong>을 확인할 수 있다. 이 두 가지 요소의 합이 바로 아비트럼 트랜잭션의 수수료가 된다.</p><p>아비트럼은 이더리움의 보안 계층을 계승한 <strong>옵티미스틱 롤업 기반의 레이어2 체인</strong>이다. 롤업은 레이어1에서 실행되던 트랜잭션을 오프체인에서 처리한 후, 트랜잭션의 데이터 요약본과 변경된 상태(state)를 레이어1에 기록하는 확장 솔루션을 의미한다.</p><ul><li>Batch Data : 아비트럼에서 발생한 모든 트랜잭션 데이터의 압축된 형태</li><li>Batch Posting : Batch Data를 이더리움에 저장하는 행위</li><li>Batch Poster : Batch Data를 이더리움에 저장하는 주체자</li></ul><p>아비트럼은 자체 체인에서 발생한 모든 트랜잭션을 압축하여 주기적으로 이더리움에 저장하며, 이 과정을 <strong>Batch Posting</strong>, 압축된 트랜잭션 데이터를 <strong>Batch Data</strong> 그리고 이를 수행하는 주체자를 <strong>Batch Poster</strong>라고 한다.</p><ul><li>Poster Fee : Batch Posting 과정에서 발생한 트랜잭션 수수료</li><li>Network Fee : 아비트럼의 트랜잭션에서 발생한 수수료</li></ul><p>Batch Posting 과정에서 발생하는 이더리움 트랜잭션 수수료는 <strong>Poster Fee</strong>로 정의되는데, 아비트럼은 사용자로부터 징수한 트랜잭션 수수료에서 Poster Fee를 충당한다. 그리고, <strong>Network Fee</strong>는 트랜잭션 실행 과정에서 발생한 네트워크 수수료를 의미한다.</p><h4>Calculaing fee</h4><ul><li><strong>Poster Fee = <em>L1 Gas Used * L2 Gas Price</em></strong>,</li><li><strong>Network Fee = <em>L2 Gas Used * L2 Gas Price</em></strong></li></ul><p>두 수수료는 위와 같은 수식으로 계산된다. 특히, <strong>L1 Gas Used</strong>와 <strong>L2 Gas Price</strong>는 아비트럼에서 자체적으로 개발한 알고리즘과 프로토콜에 의해 동적으로 결정된다. 때문에 이번 아티클에서 궁극적으로 다루는 아비트럼 수수료 모델의 전부라고 할 수 있다. ****이를 정리하면 다음과 같이 3가지 변수에 의해 최종적으로 수수료가 결정된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rvxh-ZlNeqiUXyq0TPeXuw.png" /><figcaption>[그림 2]</figcaption></figure><p>본 아티클은 수수료 모델을 톺아보기 위해 <strong>1부</strong>에서 Poster Fee와 L1 Gas Used가 계산되는 방법에 대해 집중적으로 다룰 예정이며,<strong> 2부</strong>에서는 Network Fee와 아비트럼 네트워크의 Gas Price에 대해 깊게 알아 볼 예정이다.</p><h3>Network Account</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XrJ5w5iHCgSNfk2EG9rKFw.png" /><figcaption>[그림 3] <a href="https://arbiscan.io/vmtrace?txhash=0xdcc0d65458543065604bca6d8ef4088e094b9c5e1f0e727c15ce40a634a1ee74&amp;type=gethtrace2">https://arbiscan.io/vmtrace?txhash=0xdcc0d65458543065604bca6d8ef4088e094b9c5e1f0e727c15ce40a634a1ee74&amp;type=gethtrace2</a></figcaption></figure><p>아비트럼에 트랜잭션이 제출되면, Network Fee는 <a href="https://arbiscan.io/address/0xbF5041Fc07E1c866D15c749156657B8eEd0fb649">InfraFeeAccount</a>로, Poster Fee는 <a href="https://arbiscan.io/address/0xa4B00000000000000000000000000000000000F6">L1PricerFundsPool</a>로 전달되어 각각의 계정으로 수수료가 수집된다. 이렇게 수집된 두 수수료는 아비트럼 프로토콜에서 설계한 대로 활용되고 있다.</p><blockquote>InfraFeeAccount는 <a href="https://arbiscan.io/address/0x000000000000000000000000000000000000006b#readContract#F2">ArbOwnerPublic의 getInfraFeeAccount() </a>함수를 통해 조회할 수 있으며, L1PricerFundsPool 주소는 <a href="https://github.com/OffchainLabs/nitro/blob/3767b1ffa985e50ad1c2bf84a42152db762a848e/arbos/l1pricing/l1pricing.go#L54">Nitro Core에 상수</a>로 정의되어 있다.</blockquote><p>아비트럼의 <strong>Network Fee</strong>가 수집되는 InfraFeeAccount는 스마트 컨트랙트이며, <a href="https://github.com/OffchainLabs/fund-distribution-contracts/blob/e6f0f877d90c925dfdbacb973dd7214ef912ed84/src/RewardDistributor.sol#L4"><strong>RewardDistributor.sol</strong></a>가 배포되어 있다. 이는 수집된 자금을 다수의 주소로 분배하는 역할을 수행한다. 트랜잭션 내역을 보면 해당 컨트랙트에 모인 Network Fee는 주기적으로 아비트럼 DAO의 <a href="https://docs.arbitrum.foundation/dao-glossary#timelock-contract"><strong>Timelock contract</strong></a>로 전송하고 있다. Timelock Contract는 Arbitrum DAO의 governance proposal에 따라 동작하도록 설계된 스마트 컨트랙트이다. 현재 Contract에는 약 1만 ETH가 모여 있으며, ARB Token을 활용한 governance에 의해 운용될 것으로 보인다.</p><p><a href="https://arbiscan.io/address/0xa4B00000000000000000000000000000000000F6">L1PricerFundsPool</a>에 수집된 <strong>Poster Fee</strong>는 Poster가 이더리움에서 Batch Posting를 수행하는 과정에서 발생한 수수료를 환급해 줄 때 사용된다. Poster가 Batch Data를 이더리움에 저장하는 트랜잭션을 전송하면 Batch Posting 비용을 <strong>“청구”</strong>하는 <strong>Batch Post Report</strong>가 아비트럼으로 전송되는데, 이때 Poster에 해당 수수료를 <strong>“환급”</strong>해준다. 이때 제출한 Batch Post Report의 정보에 따라 <strong>Poster Fee</strong>를 결정하는데 영향을 준다. 아래에서 자세하게 알아보자.</p><h3>Batch Poster Report</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2NeC_30xz9xI-kjP-SA7CQ.png" /><figcaption>[그림 4] <a href="https://etherscan.io/tx/0x8567c29830674aef1684b32fc1bd1fd19cb62071e18d928c79dbd6fa05956373#eventlog#362">https://etherscan.io/tx/0x8567c29830674aef1684b32fc1bd1fd19cb62071e18d928c79dbd6fa05956373#eventlog#362</a></figcaption></figure><p>Poster가 이더리움에 제출한 Batch Posting 트랜잭션의 이벤트 내역을 보면, <em>MessageDelivered</em>를 확인할 수 있다. 해당 이벤트를 디코딩해 보면<a href="https://github.com/OffchainLabs/nitro/blob/4483e77458b61c335cacd17442a7265c063ccf2c/arbos/arbostypes/incomingmessage.go#L31"> { kind: 13 }</a> 이라는 값을 볼 수 있는데, 이는 아비트럼 내에서 Batch Poster Report를 식별하기 위한 숫자이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VhRSHVudLTCxo6coqtd4xw.png" /><figcaption>[그림 5] <a href="https://arbiscan.io/tx/0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a">https://arbiscan.io/tx/0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a</a></figcaption></figure><p>이더리움에서 Batch Posting 트랜잭션이 정당성(justified)을 얻으면, 즉 약 6.4 분(1 epoch) 정도가 지나면 아비트럼의 시스템 컨트랙트에서 위와 같은 트랜잭션이 발생하는데, 이때, 트랜잭션의 Calldata를 디코딩 해보면 위 사진과 같은 데이터를 얻을 수 있다. Batch Poster Report의 <em>MessageDelivered</em> 이벤트에 기록된 batchTimestamp가 동일한 것을 통해, 해당 메시지들이 동기화된 것임을 알 수 있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*FZ_9FdmmyNdujShA2ePf9g.png" /><figcaption>[그림 6] <a href="https://arbiscan.io/vmtrace?txhash=0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a&amp;type=gethtrace2">https://arbiscan.io/vmtrace?txhash=0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a&amp;type=gethtrace2</a></figcaption></figure><p>해당 트랜잭션의 내부를 보면 두번의 전송(transfer)가 발생하는데, 이때 L1PricerFundsPool(0xa4B00000…0000000F6)로 부터(from) ETH가 전송된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B7k9twyEkqA7RT38zq7JhA.png" /><figcaption>[그림 7]</figcaption></figure><p>첫 번째 전송은 아비트럼 프로토콜에서 정한 보상자(Rewarder)에게 일부 ETH가 전송되며 보상금은 위 공식에 따라 결정된다.</p><ul><li>updateTime : Batch Poster Report가 이더리움에 작성된 시간</li><li>currentTime : Batch Poster Report 처리된 현재 시간</li><li>lastUpdateTime : 이전에 Batch Poster Report 아비트럼에 제출된 시간</li><li>UnitsSinceUpdate : 현재 축적된 Batch Data의 Size</li><li>perUintReward : 보상 비율</li></ul><p><em>updateTime</em>과 <em>currentTime</em>는 Batch Poster Report가 아비트럼에서 호출될 때 결정되지만, <em>lastUpdateTime</em>와 <em>UnitsSinceUpdate</em>, 그리고 <em>perUintReward</em>는 <a href="https://arbiscan.io/address/0x000000000000000000000000000000000000006C#readContract">ArbGasInfo Contract</a>에서 조회가 가능하다. 현재 아비트럼의 <em>perUintReward</em>는 0으로 설정되어있기에, 보상을 따로 주지 않지만, Nova Chain 또는 Orbit Chain(L3)에서 활용될 수 있는 기능으로 남겨져 있다.</p><blockquote>Rewarder의 주소는<a href="https://arbiscan.io/address/0x000000000000000000000000000000000000006C#readContract#F15"> ArbGasInfo Contract의 getL1RewardRecipient() 함수</a>를 통해 조회할 수 있는데, 몇달 전까지 해당 주소로 보상을 전송하고 있던것 같다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*04TlFccKAZLZKY8uvg_ZXQ.png" /><figcaption>[그림 8] <a href="https://arbiscan.io/tx/0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a">https://arbiscan.io/tx/0x09edeb0c6fadf166d84afd60ad7d9d1b5aaa335a54f3b5650daf745ba3eee55a</a></figcaption></figure><p>두 번째로, 해당 트랜잭션에서 ETH의 유동성을 확인해 보면, 0.00553 ETH가 L1PricerFundsPool에서 Poster에게 전송된 것을 알 수 있다. 이는 아비트럼에서 Poster에게 이더리움에서 사용한 Batch Posting 트랜잭션 수수료를 환급해 준 것이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*4papo9GRvYfuxBZWTO4rtw.png" /><figcaption>[그림 9]</figcaption></figure><p>환급된 비용은 위의 공식에 따라 계산된다.</p><ul><li>BatchDataGas : 이더리움에 저장된 Batch Data Size * 16</li><li>l1BaseFeeWei : 당시 트랜잭션의 L1 Base Fee</li></ul><p>예시로 든 Batch Poster Report의 데이터를 보면, 21978660780 * (42000 + 210000) ≈ 0.00553 ETH가 정확하게 계산된 것을 확인할 수 있다.</p><blockquote><em>perBatchGas</em>는 <a href="https://arbiscan.io/address/0x000000000000000000000000000000000000006C#readContract#F19">ArbGasInfo Contract의 getPerBatchGasCharge() 함수</a>를 통해 조회할 수 있다.</blockquote><p>아비트럼은 L1PricerFundsPool에서 Poster와 Rewarder에게 환급금과 보상금을 지급한 후, 남은 금액을<strong> 잉여금(이하 L1 Surplus)</strong>라고 정의한다. L1PricerFundsPool에 Poster와 Rewarder에게 <strong>환급금</strong>과 <strong>보상금</strong>을 지급하기에 충분한 잔액이 있다면, L1 Surplus는 환급금과 보상금을 지급한 후에도 남아 있게 된다. 이렇게 잔액이 계속해서 축적되면 L1 Surplus가 양수(+)가 된다. 이 경우, 금액이 남아 Poster Fee를 필요 이상으로 받을 필요가 없으니, 사용자로부터 받는 <strong>Poster Fee</strong>는 줄어들게 된다. 반면, L1PricerFundsPool의 잔액이 Poster가 청구한 환급금보다 적어 L1 Surplus가 부족할 경우, 음수(-)가 될 수 있다. 이 경우 밀린 환급금과 보상금을 다음 번에 지급해야 하므로, 사용자로부터 받는 <strong>Poster Fee</strong>는 증가하게 된다.<br><strong>Poster Fee</strong>는 <em>L1 Gas Used * L2 Gas Price</em>에 의해 결정되는데, 이때 <strong><em>L1 Gas Used</em></strong>는 L1 Surplus는 음수인지 양수인지에 따라 영향을 받는다.</p><blockquote>이더리움의 네트워크가 혼잡해지면서 갑작스럽게 Base Fee가 급증하는 경우, L1PricerFundsPool에 준비된 금액보다 높은 환급금이 발생할 수 있다.</blockquote><h3>L1 Data Metering and Pricing</h3><p><strong>“L1 Gas Used”</strong>란 개별 트랜잭션이 이더리움에 Batch Posting되는 과정에서 발생하는 예상 비용을 “L1 Gas”로 환산한 값을 의미한다. 이 값은 트랜잭션의 크기와 아비트럼 노드 프로그램(이하 <a href="https://github.com/OffchainLabs/nitro">Nitro</a>)에 구현된 동적 알고리즘에 따라 결정된다.</p><h4>Estimated L1 Base Fee : pricePerUint</h4><p>Batch Posting은 사용자의 트랜잭션이 아비트럼에 다수 수집된 후 이더리움에 저장된다. 즉, 트랜잭션을 전송한 사용자가 예상되는 수수료를 먼저 지출하는 구조이다. 이에 따라 아비트럼은 미래에 이더리움에 전송될 Batch Posting 트랜잭션의 Gas Price를 미리 예측하여 사용자로부터 수수료를 받게 되며 pricePerUint라고 정의했다. 아비트럼은 이를 예측하기 위해 <strong>smoothing factor(평활 계수) 알고리즘</strong>을 사용한다.</p><blockquote>현재 결정된 pricePerUint는 <a href="https://arbiscan.io/address/0x000000000000000000000000000000000000006C#readContract#F6">ArbGasInfo의 getL1BaseFeeEstimate() 함수</a>를 통해 현재 값을 조회할 수 있다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*J4KivaA5NQPmcyBLn5CJfA.png" /><figcaption>[그림 10]</figcaption></figure><p><strong>smoothing factor(평활 계수) 알고리즘</strong>는 데이터 분석, 예측 모델링, 신호 처리 등의 분야에서 데이터의 패턴을 강조하기 위해 주로 사용되는 알고리즘이며, 예측하기 힘든 케이스의 변동폭을 평균화 시키기 위해 사용된다. 이때 평균치를 유지시켜주는 <strong>평활 계수(<em>α</em>)</strong>로 Batch Poster Report에서 생성된 시간 데이터를 사용한다.</p><p>L1 Surplus가 음수(-)일 경우, 예측되는 이더리움의 pricePerUint(= Estimated L1 Base Fee)가 증가하고, 반대로 L1 Surplus가 양수(+)일 경우에는 pricePerUint가 감소한다. 이렇게 구해낸 예측된 Estimated L1 Base Fee는 Nitro Core에서 <a href="https://github.com/OffchainLabs/nitro/blob/4bfb5398b1a74afb7f99e596aadca25e0a6ff2c7/arbos/l1pricing/l1pricing.go#L234"><strong>pricePerUint</strong></a>라는 변수에 정의되어 있다.</p><blockquote>실제 아비트럼에 구현된 smoothing factor(평활 계수) 알고리즘 공식은 <a href="https://github.com/OffchainLabs/nitro/blob/4bfb5398b1a74afb7f99e596aadca25e0a6ff2c7/arbos/l1pricing/l1pricing.go#L303">Nitro의 l1Pricing.go</a>에서 확인할 수 있다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*ybg-fFsjtIqRhe3AgiGEjg.png" /><figcaption>[그림 11] L1 Gas Used 공식</figcaption></figure><p>smoothing factor(평활 계수) 알고리즘으로 구해낸 pricePerUint는 위 공식과 같이 L1 Gas Used를 구하는데 사용된다. 위 공식에 따르면 L1 Surplus가 음수인지 양수인지에 따라 pricePerUint가 감소 또는 증가하기에, L1 Gas Used 또한 자연스럽게 같이 감소 또는 증가하게 된다. <br>이어서 Nitro Core Code를 보고 L1 Gas Used를 어떻게 결정하는지 알아보자.</p><h4>L1 Calldata Size</h4><pre>// https://github.com/OffchainLabs/nitro/blob/41592b404ddef032e348ca310e8808fc73e49be6/arbos/l1pricing/l1pricing.go#L501<br>func (ps *L1PricingState) getPosterUnitsWithoutCache(tx *types.Transaction, posterAddr common.Address, brotliCompressionLevel uint64) uint64 {<br><br> ...<br> txBytes, merr := tx.MarshalBinary()<br> txType := tx.Type()<br> l1Bytes, err := byteCountAfterBrotliLevel(txBytes, int(brotliCompressionLevel))<br> ...<br> return l1Bytes * params.TxDataNonZeroGasEIP2028 // 16<br>}</pre><p>시퀀서는 먼저 RLP 인코딩된 트랜잭션(또는 <a href="https://ethereum.stackexchange.com/questions/77719/what-does-it-mean-to-serialize-a-transaction">serialized transaction</a>)을 <a href="https://developer.mozilla.org/ko/docs/Glossary/Brotli_compression">Brotli 알고리즘</a>으로 압축한 후, 압축된 크기(size)에 16을 곱하며, 이를 <strong>L1 Calldata Size</strong>로 정의한다. 이는 아비트럼의 Batch Data가 Brotli으로 압축된 트랜잭션을 Calldata에 담기 때문이며, 이더리움에서는 Calldata에 담긴 데이터당 16 Gas가 부과되기 때문이다.<br>일반적으로 Brotli 알고리즘으로 압축된 Legacy 트랜잭션의 경우 평균 크기는 118 bytes이며, 여기에 16을 곱하면 약 1888의 <em>L1 Gas</em>가 발생한다고 할 수 있다.</p><blockquote>아비트럼의 Batch Data는 이전에는 트랜잭션의 Calldata에 기록되었다. 이더리움의 Istanbul 업데이트를 통해 도입된 EIP-2028은 Calldata의 1byte당 16 gas를 부과하는 규정을 적용하여, 아비트럼도 이 규정에 따라 Batch Data의 크기에 16을 곱하여 L1 Gas Used를 계산했다. 최근 Dancun 업데이트 이후, 아비트럼은 EIP -4844로 도입된 Blob에 Batch Data를 저장하고 있지만, L1 Gas Used의 계산 방식은 여전히 Calldata를 기준으로 동일하게 유지되고 있다.</blockquote><pre>// GetPosterInfo returns the poster cost and the calldata units for a transaction<br>func (ps *L1PricingState) GetPosterInfo(tx *types.Transaction, poster common.Address, brotliCompressionLevel uint64) (*big.Int, uint64) {<br> <br> ...<br> <br> units := atomic.LoadUint64(&amp;tx.CalldataUnits)<br> if units == 0 {<br>  units = ps.getPosterUnitsWithoutCache(tx, poster, brotliCompressionLevel)<br>  atomic.StoreUint64(&amp;tx.CalldataUnits, units)<br> }<br><br> // Approximate the l1 fee charged for posting this tx&#39;s calldata<br> pricePerUnit, _ := ps.PricePerUnit()<br> return am.BigMulByUint(pricePerUnit, units), units<br>}</pre><p>이후, L1 Calldata Size에 <em>pricePerUnit</em>를 곱한다. 위에서 설명했던것 처럼 <em>pricePerUnit</em>은 이더리움에 Batch Posting할 때 발생하는 트랜잭션의 L1 Base Fee 예상치를 의미한다. 즉, 이더리움으로 Batch Posting 될 때 Poster가 지출하는 트랜잭션 비용(이하 Poster Cost) 중 내 트랜잭션이 저장되면서 차지하는 수수료를 산출한 것이다.</p><h4>L2 Base Fee(<em>L2 Gas Price)</em></h4><pre>func GetPosterGas(state *arbosState.ArbosState, baseFee *big.Int, runMode core.MessageRunMode, posterCost *big.Int) uint64 {<br> if runMode == core.MessageGasEstimationMode {<br>  // Suggest the amount of gas needed for a given amount of ETH is higher in case of congestion.<br>  // This will help the user pad the total they&#39;ll pay in case the price rises a bit.<br>  // Note, reducing the poster cost will increase share the network fee gets, not reduce the total.<br><br>  minGasPrice, _ := state.L2PricingState().MinBaseFeeWei()<br><br>  adjustedPrice := arbmath.BigMulByFrac(baseFee, 7, 8) // assume congestion<br>  if arbmath.BigLessThan(adjustedPrice, minGasPrice) {<br>   adjustedPrice = minGasPrice<br>  }<br>  baseFee = adjustedPrice<br><br>  // Pad the L1 cost in case the L1 gas price rises<br>  posterCost = arbmath.BigMulByBips(posterCost, GasEstimationL1PricePadding)<br> }<br><br> return arbmath.BigToUintSaturating(arbmath.BigDiv(posterCost, baseFee))<br>}</pre><p>마지막으로 위에서 구한 Poster Cost에 <strong>Base Fee</strong>(또는 L2 Gas Price)를 나누면 우리가 구하고자 하는 <strong>“L1 Gas Used”</strong>가 된다. 여기서 사용하는 baseFee는 아비트럼 네트워크의 현재 <strong><em>L2 Gas Price</em></strong>를 의미한다.</p><blockquote><em>L2 Gas Price에 대한 자세한 내용은 2부에서 알아 볼 예정이다.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/1*oUcARmSyf-q9a4cOMWvF7Q.png" /><figcaption>[그림 12]</figcaption></figure><p><strong><em>MessageGasEstimationMode</em></strong>는 NodeInterface Contract의 gasEstimateComponents() 함수를 통해 트랜잭션 수수료 예상치를 측정(estimate)하는 경우 실행하며, 나름 트랜잭션이 성공할 수 있는 수수료가 산출되는 수식이 적용되어 있다. 이더리움의 네트워크가 혼잡할 것을 예상하여 Poster Cost에 10%를 추가하고, L2 Base Fee의 변동폭을 고려하여 약 7/8을 곱하여 예상치를 측정한다.</p><blockquote>이더리움의 eth.estimateGas 기능이 있듯히, 아비트럼의 Precompiled Contract 중 NodeInterface Contract는 <a href="https://arbiscan.io/address/0x00000000000000000000000000000000000000C8#writeContract#F2">gasEstimateComponents(address to, bool contractCreation, bytes calldata data)</a> 함수를 제공하여, 트랜잭션을 전송하기 전에 수수료를 추정할 수 있는 기능을 지원한다. 사용자는 이 함수를 통해 트랜잭션 수신자(to), Contract 생성 여부(contractCreation), 호출 데이터(calldata)를 파라미터로 제공하고, 이를 기반으로 수수료를 추정할 수 있다. (사용 예시로 <a href="https://github.com/OffchainLabs/arbitrum-tutorials/blob/master/packages/gas-estimation/scripts/exec.ts">아비트럼 튜토리얼</a>을 참고하면 좋을것 같다.)</blockquote><h3>마치며</h3><p>지금까지 아비트럼의 수수료 모델 중 Poster Fee에 대해 알아보았다. 정리하자면, Poster Fee는 사용자의 트랜잭션이 Batch Posting 될 때 발생하는 예상 비용을 청구한 금액을 의미한다. 이 Poster Fee는 Batch Post Report에 따라 동적으로 변동되며, 아비트럼에 축적된 L1 Surplus에 따라 상승하거나 하락한다.</p><p>하지만,<strong><em> ‘[그림 11] L1 Gas Used 공식’</em></strong>을 보면 L1 Calldata * L1 Gas Used에 L2 Gas Price(Base Fee)를 나눈다. 이때, L2 Gas Price는 아비트럼 네트워크의 현재 가스 가격을 의미하며, 이더리움 처럼 네트워크 혼잡도에 따라 동적으로 결정된다. 하지만 EIP-1559에 따라 동작하는 이더리움과 달리 아비트럼에서 자체적으로 만든 프로토콜에 의해 동작한다.</p><p>이번 1부에 이어, 다음 2부에서는 아비트럼의 Network Fee와 L2 Gas Price에 대해 알아볼 예정이다. 최종적으로 사용자가 아비트럼에서 지출하는 트랜잭션 수수료를 완벽하게 이해할 수 있도록 아비트럼 트랜잭션 수수료 모델을 톺아볼 예정이니 기대 바라며 이로써 1부를 마친다.</p><h3>Reference</h3><ul><li><strong>[Offchain Labs]</strong> <strong>Understanding Arbitrum: 2-Dimensional Fees :</strong> <a href="https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9">https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9</a></li><li><strong>[Arbitrum Docs] Gas and Fees :</strong> <a href="https://docs.arbitrum.io/how-arbitrum-works/gas-fees">https://docs.arbitrum.io/how-arbitrum-works/gas-fees</a></li><li><strong>[Arbitrum Docs] gas-and-fees(inside-arbitrum-nitro)</strong> : <a href="https://docs.arbitrum.io/how-arbitrum-works/inside-arbitrum-nitro#gas-and-fees">https://docs.arbitrum.io/how-arbitrum-works/inside-arbitrum-nitro#gas-and-fees</a></li><li><strong>[Offchain Labs Github] Nitro :</strong> <a href="https://github.com/OffchainLabs/nitro">https://github.com/OffchainLabs/nitro</a></li><li><strong>[Offchain Labs Github] Nitro-whitepaper :</strong> <a href="https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf">https://github.com/OffchainLabs/nitro/blob/master/docs/Nitro-whitepaper.pdf</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f62901204975" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BitVM: Smarter Bitcoin Smarter (상)]]></title>
            <link>https://medium.com/decipher-media/bitvm-smarter-bitcoin-smarter-%EC%83%81-cf8ae5176042?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf8ae5176042</guid>
            <category><![CDATA[blockchai̇n]]></category>
            <category><![CDATA[bitcoin]]></category>
            <category><![CDATA[bitvm]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Sun, 07 Jul 2024 10:05:59 GMT</pubDate>
            <atom:updated>2024-09-01T14:32:29.626Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Disclaimer : 서울대학교 블록체인 학회 디사이퍼(Decipher)에서 `BitVM: Smarter Bitcoin Smarter`을 주제로 Weekly Session에서 발표한 내용을 바탕으로 합니다. 본 아티클은 BitVM의 기술적 내용과 이를 이해하기 위한 Bitcoin의 기본적인 동작 방법 등에 대한 내용을 다루고 있습니다. 이 보고서에 포함된 어떠한 내용도 투자 조언이 아니며, 투자 조언으로 해석되어서도 안 됩니다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mZcd6Rzz99pmkwrwF8EReA.png" /></figure><h3>시리즈</h3><ol><li><strong>BitVM: Smarter Bitcoin Smarter (상)</strong></li><li><a href="https://medium.com/decipher-media/bitvm-smarter-bitcoin-smarter-%ED%95%98-55b2b20cd1cf">BitVM: Smarter Bitcoin Smarter (하)</a></li></ol><h3>Author</h3><p>최원재, 최원혁 of Decipher Seoul Nat’l Univ. Blockchain Academy Decipher(<a href="https://medium.com/decipher-media">@decipher-media</a>)</p><p>Reviewed By 신성헌, 박순종, 최재우</p><h3>Table of Contents</h3><p><strong>1. Intro : Why BitVM</strong></p><p><strong>2. Bitcoin Layer2</strong></p><ul><li>Client Side Validation</li><li>Side Chain</li><li>BitVM</li></ul><p><strong>3. Background for BitVM</strong></p><ul><li>비트코인 Script</li><li>Pay to Public Key Hash (P2PKH)</li><li>Hashed Time Lock Contract (HTLC)</li><li>Segwit — Witness</li><li>Pay-to-Taproot (P2TR)</li><li>Merkelized Alternative Script Tree (MAST)</li></ul><p><strong>4. 마치며</strong></p><h3>Abstract</h3><p>BitVM은 비트코인에서 스마트컨트랙트를 구현할 수 없는 한계를 극복하기 위해 등장한 Layer2 솔루션이다. 본 아티클은 비트코인이 스마트컨트랙트를 구현할 수 없는 이유와 BitVM의 기술적 측면에 대해 깊이 있게 다루며, 1부에서 BitVM을 이해하기 위한 사전지식으로 <strong>입문자를 위한 비트코인의 동작 원리</strong>을 먼저 알아보고, 2부에서 본격적으로 BitVM에 대해 알아볼 예정이다.</p><h3>1. Intro : Why BitVM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*fFR4NbuxWKDyZfHkpmdzzQ.png" /><figcaption>Source : Decipher</figcaption></figure><p>가장 이상적인 블록체인은 보안성(Security), 탈중앙화(Decentralization), 확장성(Scalability)이라는 세 가지 요소를 모두 충족하는 것이다. 그러나 기술적 한계로 인해 이 중 하나를 포기해야 하는데, 이를 블록체인 트릴레마(Blockchain Trilemma)라고 한다. 비트코인은 이 트릴레마에서 확장성을 포기하고, 탈중앙화와 보안성에 중점을 두어 설계되었다. 이러한 목표를 달성하기 위해 비트코인은 의도적으로 <strong>튜링 불완전한(Turing incomplete) Script</strong>를 선택하게 되었고, 이로 인해 <strong>스마트컨트랙트를 구현할 수 없는 한계</strong>를 갖게 되었다.</p><p>튜링 불완전성(Turing incomplete)은 프로그래밍 언어의 계산 능력이 일부 의도적으로 제한된 것을 의미하며, 주로 반복문(Loop)이나 재귀 함수(Recursion Function)의 사용이 제한된다. 비트코인은 이러한 튜링 불완전성을 갖는 언어인 <strong>Script</strong>를 통해 거래를 처리하고 검증한다. 탈중앙화를 목표로 하는 비트코인 시스템에서는 모든 노드가 트랜잭션을 빠르고 효율적으로 처리하여 합의에 도달하는 것이 필수적이다. 또한, Script를 실행하는 노드가 DoS와 같은 무한 반복 공격을 받지 않도록 보호해야 한다. 이러한 이유로, 비트코인은 복잡한 코드나 반복되는 Loop문 및 재귀 함수의 사용이 제한되는 튜링 불완전 언어를 의도적으로 채택하였다.</p><p>이처럼 Script는 시스템의 실행이 단순하고 보안적으로 장점을 갖는 반면, 이더리움의 ERC20이나 zkEVM과 같은 복잡한 스마트컨트랙트를 구현할 수 없는 한계를 가진다. 때문에, 비트코인이 직면한 한계를 해결하고자 새롭게 등장한 Layer2 솔루션이 바로 <strong>BitVM</strong>이다.</p><h3>2. Bitcoin Layer2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZvpuQenE7JPFVu0oP_gSbw.png" /><figcaption>Source : Decipher</figcaption></figure><p>비트코인 Layer2 솔루션은 비트코인의 근본적인 문제를 해결하기 위해 제안된 다양한 솔루션 중 하나이며, 빠른 속도와 낮은 트랜잭션 비용, 그리고 튜링 완전한 스마트컨트랙트 등 비트코인에서 사실상 불가능했던 영역을 오프체인에서 수행하는 방식으로 한계점들을 해결한다. 비트코인 Layer2는 비트코인의 하드포크 없이 구현이 가능하며, 이로 인해 비트코인 네트워크의 보안과 탈중앙화 특성이 유지될 수 있다.</p><p>BitVM을 살펴보기 전에, 우선 현존하는 비트코인 Layer2 솔루션들을 알아보고 각 솔루션들이 비트코인의 어떤 한계점들을 해결하고자 하는지, 그리고 BitVM 역시 Layer2 솔루션으로 어떠한 방법으로 문제들을 해결하고 있는지 알아보자.</p><h4>Client Side Validation</h4><p>Client Side Validation은 최근 많은 주목을 받고 있는 Layer2 솔루션 중 하나이다. 거래라는 행위에는 이체인과 수령인이 있으며, 비트코인 네트워크에서 트랜잭션은 두 당사자의 거래 단위를 의미한다. 비트코인은 모든 노드가 다수의 트랜잭션을 처리하고 검증하는 과정에서 속도가 느려진다. Client Side Validation는 이런 문제를 개선하기 위해 오프체인에서 거래 당사자들이 직접 트랜잭션을 검증하고 실행한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F7PrzH2l99Bh-UX-wiK_jQ.png" /><figcaption>Source : Decipher</figcaption></figure><p>Client Side Validation을 이용하는 사용자는 거래가 성립될 때마다 거래 내역을 Layer1(비트코인)에 저장하고, 자신의 로컬 장치에 필요한 데이터와 잔액 정보를 보관한다. 이후 다른 거래가 발생할 때, 이체인은 거래 내역을 역추적하여 자신의 자산을 증명하는 Proof of asset으로 활용한다. 거래가 진행되면, 수령인은 이체인의 Proof of asset을 통해 온체인에 기록된 내역을 역추적하고, 이를 통해 이체인이 충분한 금액을 보유하고 있음을 검증할 수 있다.</p><p>그러나, Client Side Validation는 거래 기록이 누적되면서 데이터의 양이 커지고, 이로 인해 수령인이 검증해야 할 과정이 점점 복잡해지고 느려진다. 이 문제를 해결하기 위해 요즘에는 Proof of asset을 관리하고 검증을 대행해주는 <strong>Indexer</strong>를 사용한다.</p><h4>Side Chain</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pM0TKiyQ89BecQsjNMT-Xw.png" /><figcaption>Source : Decipher</figcaption></figure><p><strong>Side Chain</strong>은 비트코인과 병렬로 운영되는 별도의 블록체인이다. 비트코인과는 다른 독립적인 컨센서스를 사용하며, 탈중앙성과 보안성이 부족하더라도 확장성에 특화되어 있다. 또한, Bridge 기술을 통해 Side Chain과 비트코인 네트워크 간 <strong>상호 운영성(Interoperability)</strong>을 갖는다. 덕분에 사용자들은 더 나은 환경에서 비트코인을 활용할 수 있는 생태계를 제공받게 된다.</p><p>Layer1의 보안과 탈중앙성을 상속받는 Layer2 솔루션과는 다르게, Side Chain은 독립적인 체인으로 서로 다른 솔루션으로 논의된다. 하지만, <a href="https://github.com/stacks-network/stacks/blob/master/stacks-l2.md"><strong>Stacks의 공동 창립자의 주장</strong></a>처럼 비트코인 네트워크의 완결성을 따르거나 비트코인을 네이티브 코인으로 활용하는 경우, Side Chain이라도 Layer2 솔루션으로 봐야 한다는 논의가 계속되고 있다. 중요한 점은 두 솔루션 모두 오프체인에서 비트코인의 확장성 문제를 해결하고자 하는 공통된 목적을 갖고 있다는 것이다.</p><h4>BitVM</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i7NKL8Tp3JsdD9fHvu_0Lw.png" /><figcaption>Source : Decipher</figcaption></figure><p>위에서 언급한 두 가지 솔루션은 비트코인의 느린 거래 속도와 비싼 가스비를 개선하기 위해 거래 또는 합의(컨센서스)를 오프체인에서 수행한다. 이와 같이 <strong>BitVM</strong>은 비트코인에서 스마트컨트랙트를 구현할 수 없는 한계를 개선하기 위해 <strong>복잡한 코드를 오프체인</strong>에서 실행한다.</p><p>BitVM은 코드를 연산하는 하나의 <strong>가상 머신(Virtual Machine)</strong>이다. 이더리움의 EVM과 유사하게, 탈중앙화 시스템에서 신뢰와 무결성(integrity)을 갖는 스마트컨트랙트를 실행하는 가상 머신을 구현하는 것을 목표로 한다. 하지만 다수의 노드에 의해 검증되는 이더리움의 스마트컨트랙트와 달리, BitVM은 오프체인에서 동작하기 때문에 별도의 검증 과정이 필요하다. 이를 위해 BitVM은 구현된 코드를 오프체인(Layer2)에서 실행하고 검증자(Verifier)에 의해 주기적으로 검사를 받는다. 검증 과정에서 오류가 발견되거나 부정 행위가 발견되면, 비트코인 네트워크(Layer1)에서 사기 증명(fraud proofs)을 통해 검증하고, 부적절하게 실행한 주체에 대한 처벌이 이루어진다. 이 과정은 롤업의 <strong>Optimistic</strong> 방식과 매우 유사하다. 또한, BitVM의 이러한 프로세스는 비트코인의 추가적인 업데이트 없이도 <strong>Script</strong>와 Taproot의 <strong>Merkelized Alternative Script Tree (MAST)</strong>를 사용하여 구현할 수 있다는 특징을 갖고 있다.</p><h3>3. Background for BitVM</h3><p>2부 아티클에서 다루는 BitVM은 주로 기술적인 요소와 위에서 설명한 사기증명(fraud proofs)에 대한 자세한 내용이 포함되어 있다. 따라서 1부는 이를 이해하기 위해 필요한 배경 지식을 먼저 소개할 예정이다. 배경에서 다루는 내용은 비트코인 Script의 동작 원리와 Taproot의 Merkelized Alternative Script Tree (MAST)에 관한 것이며, 이미 사전 지식이 있는 독자는 바로 BitVM 부분으로 넘어가도 문제가 없을 것이다.</p><h4>비트코인 Script</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H9kVB-4K3SFDeK9dURBFXQ.png" /><figcaption><a href="https://i.sstatic.net/ehk1f.jpg">https://i.sstatic.net/ehk1f.jpg</a></figcaption></figure><p>비트코인의 Script는 Opcode 기반의 프로그래밍 언어이다. 위 사진에 나와 있는 약 110개의 Opcode를 조합하여 튜링 불완전한 로직을 구현할 수 있다. Script는 UTXO의 input과 output, 즉 해제 Script와 잠금 Script로 구현된다. 비트코인 네트워크로 제출된 트랜잭션의 해제 Script와 잠금 Script가 순차적으로 실행하, 최종적으로 <em>True</em>라는 실행 결과를 얻게 되면 트랜잭션이 성공하는 메커니즘이다.</p><h4>Pay to Public Key Hash (P2PKH)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Gmci7oiv4mN3gNO2F3hJ5g.png" /><figcaption><a href="https://iq.opengenus.org/locking-and-unlocking-scripts-in-bitcoin/">https://iq.opengenus.org/locking-and-unlocking-scripts-in-bitcoin/</a></figcaption></figure><p>P2PKH는 비트코인에서 Script로 구현할 수 있는 가장 대표적인 로직으로, 비트코인을 전송할 때 해당 UTXO의 소유권을 증명할 수 있는 서명을 검증하는 기능이 구현되어 있다. 해제 Script에는 서명 데이터(sig)와 공개키(PubK)가 포함되어 있으며, 잠금 Script는 해당 UTXO를 소유 중인 공개키의 해시(PubKHash)와 해제 스크립트의 서명을 검증하는 Opcode로 구성되어 있다. Script는 실행되는 환경의 Stack에 <strong>First In Last Out(FILO)</strong> 방식으로 데이터와 Opcode를 처리한다. P2PKH를 통해 Script가 동작하는 원리에 대해 알아보자.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c2gV4eqYBbf9qUhOB5jCrw.png" /><figcaption>2017 Mastering Bitcoin: Programming the Open Blockchain</figcaption></figure><p>1. P2PKH의 해제 Script에 있는 서명(sig)과 공개키(PubK)가 순차적으로 스택에 저장된다.</p><p>2. Opcode DUP은 Stack 최상단 데이터를 복사하는 기능을 가지고 있으며, DUP이 실행됨에 따라 Stack에 PubK가 저장된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wfuW2vcsZt4BtKhHfxjwxg.png" /><figcaption>2017 Mastering Bitcoin: Programming the Open Blockchain</figcaption></figure><p>3. Opcode HASH160은 Stack 최상단 데이터를 Hash하는 기능을 가지고 있으며, HASH160이 실행됨에 따라 Stack의 최상단에 위치한 해제 Script의 PubK은 PubKHash로 처리된다.</p><p>4. 잠금 Script에 있는 PubKHash를 Stack 최상단에 저장한다.</p><p>5. Opcode EQUALVERIFY는 Stack 최상단의 데이터 두개가 동일한지 비교하는 기능을 가지고 있으며, EQUALVERIFY가 실행됨에 따라 해제 Script의 PubKHash와 잠금 Script의 PubKHash가 동일한지 검증한다.</p><p>6. Opcode CHECKSIG는 Stack에 남은 서명 데이터(sig)를 검증하는 기능을 가지고 있으며, CHECKSIG가 실행됨에 따라 현재 Stack에 남아 있는 서명 데이터(sig)가 공개키 주소(PubK)로 생성된 서명인지 검증한다.</p><p>Script의 모든 Opcode가 실행되고 Stack에는 True만 남게 되면 트랜잭션은 성공적으로 종료된다.</p><h4>Hashed Time Lock Contract (HTLC)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/272/1*HpDGrFH9HE60TYDhZsHQHw.png" /><figcaption>Source : Decipher</figcaption></figure><p>P2PKH 외에 Script의 Opcode를 잘 구성하면 다양한 로직을 구현할 수 있으며, 그 대표적인 사례가 <strong>Hashed Time Lock Contract(이하 HTCL)</strong>이다. HTCL은 거래하는 두 당사자 간 조건이 충족될 때까지 비트코인을 잠그는 기능이 구현된 Script이다. 비트코인 사용자는 신뢰 가능한 계약 또는 거래에 HTCL을 사용한다.</p><p>HTCL은 <strong>Hash Lock</strong>과 <strong>Time Lock</strong>이라는 두 가지 조건에 따라 로직이 분기된다. Hash Lock은 사전에 합의된 비밀 키(Secret)가 제출되면 비트코인의 잠금을 해제하는 로직이 구현되어 있다. 반면, Time Lock은 특정 시간 안에 합의가 이루어지지 않으면 비트코인을 잠근 원래 주인에게 반환하는 로직이 구현되어 있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*YuaA-dK_hxdAtMO8b5KfXw.png" /><figcaption><a href="https://scryptplatform.medium.com/cross-chain-atomic-swaps-f13e874fcaa7">https://scryptplatform.medium.com/cross-chain-atomic-swaps-f13e874fcaa7</a></figcaption></figure><p>HTLC를 이해하기 위한 대표적인 예시로 Atomic Swap이 있다. Atomic Swap은 블록체인 기술을 활용하여 서로 다른 암호화폐 자산을 신뢰 가능한 P2P(Peer-to-Peer) 방식으로 거래할 수 있게 하는 기술이다.</p><p>예를 들어, Alice와 Bob이 서로 비트코인에스브이(BSV)와 비트코인(BTC) 거래를 원하는 상황에서, 서로 다른 네트워크의 자산을 가지고 있음에도 HTLC를 활용하면 신뢰 가능한 거래가 가능하다.</p><ol><li>먼저, Alice는 자신만 알고 있는 Secret의 Hash로 HTLC에 거래하고자 하는 양의 BSV를 잠근다. 해당 HTLC의 Hash Lock이 호출되면 잠긴 BSV는 Bob에게 전송되도록 설정된다.</li><li>Bob은 Alice가 제공한 Hash된 Secret을 이용해 HTLC에 거래하고자 하는 양의 BTC를 잠근다. 마찬가지로, 해당 HTLC의 Hash Lock이 호출되면 잠긴 BTC는 Alice에게 전송되도록 설정되어 있다.</li><li>Secret을 알고 있는 Alice는 Bob이 만든 HTLC의 Hash Lock을 해제하고 자산을 인출한다. 이 과정에서 Secret은 온체인에 제출되기 때문에, Bob을 포함한 누구든지 이를 확인할 수 있다.</li><li>Alice의 Secret을 확인한 Bob은 Alice가 만든 HTLC의 Hash Lock을 해제하고 자산을 인출하며, 최종적으로 두 사람의 거래가 성사된다.</li></ol><p>이처럼 HTLC를 활용한 Atomic Swap은 거래하는 두 당사자의 순차적인 행동에 따라 진행된다. 하지만, Alice가 온체인에 Secret을 제출하지 않거나, Bob이 HTLC를 생성하지 않는 등 악의적인 행동을 취할 가능성이 있다. 이러한 경우 HTLC는 Time Lock을 안전장치로 활용하여 문제를 방지할 수 있다.</p><blockquote>BitVM은 사기 증명 과정에서 Hash Lock과 Time Lock을 활용하여 challenge를 수행하며, 2부에서 자세하게 다룰 예정이다.</blockquote><h4>Segwit — Witness</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pUYrXvIJyLIo7gjjhUk5kg.png" /><figcaption><a href="https://river.com/learn/what-is-segwit/">https://river.com/learn/what-is-segwit/</a></figcaption></figure><p>HTLC처럼 Script로 구현할 수 있는 다양한 서비스 로직이 개발되면서 Script의 사이즈 또한 늘어나게 된다. 이에 따라 자연스럽게 트랜잭션의 사이즈가 커지기 시작했고, 이로 인해 비트코인의 정해진 1 MB 블록 사이즈 내에 담을 수 있는 트랜잭션의 양이 줄어들면서 확장성 문제가 발생하기 시작했다. 이러한 문제를 해결하기 위해 비트코인 생태계는 Segwit 업데이트를 도입하여 Witness라는 별도의 저장 공간을 만들어 용량이 큰 서명 데이터를 별도로 보관함으로써 확장성 문제를 개선했다.</p><h4>Pay-to-Taproot (P2TR)</h4><p>비트코인 생태계는 Segwit 업데이트 이후, Witness라는 공간에 서명 데이터뿐만 아니라 Script 코드를 저장하여 Script가 차지하는 용량을 효율적으로 처리하자는 아이디어가 제안(BIP-341)되었고, 이러한 제안은 비트코인의 Taproot 업데이트를 통해 P2TR 포맷이 네트워크에 도입되었다.</p><p><strong>P2TR</strong>은 비트코인의 새로운 송금 방식으로, 사용자는 선택적으로 기존의 P2PKH을 통해 단순한 서명 검증 Script를 실행하거나, <strong>Merkelized Alternative Script Tree (이하 MAST)</strong>의 머클루트를 검증하는 방식으로 Witness에 있는 Script를 실행할 수 있게 되었다.</p><blockquote>P2TR를 사용하는 지갑은 <a href="https://www.ledger.com/academy/glossary/wallet-address">Taproot Wallet</a>을 사용해야 하며, ‘<em>bc1p</em>’로 시작하는 Bech32m으로 인코딩된 형식의 주소를 사용해야 한다.</blockquote><h4>Merkelized Alternative Script Tree (MAST)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TrOxaWT-SCyVG6YBDXe0KQ.png" /><figcaption>Source : Decipher</figcaption></figure><p>MAST는 실행하고자 하는 Script를 작게 나누어 만든 머클 트리(Merkle Tree) 구조를 의미하며, 전체 Script 중 특정 상황 또는 조건문(OP_IF)에 따라 실행되는 Script가 분리된다. P2TR은 이 분리된 구조에서 필요한 Script가 위치한 경로를 Witness에서 추적하여 실행한다. 때문에, 블록은 Witness에 실행하고자 하는 Script 부분만을 저장하게 되어, 사용되지 않는 Script는 블록에 저장되지 않는다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lRa4Sx0_XqxQ-_HgxOTKFQ.png" /><figcaption>Source : Decipher</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OeQRrEWTdbSQRkR458R48w.png" /><figcaption>Source : Decipher</figcaption></figure><p>위에서 알아본 HTLC의 예를 들면, HTLC는 조건에 따라 <strong>Hash Lock</strong>과 <strong>Time Lock</strong>으로 실행되는 코드가 나누어진다. 만약 Hash Lock 부분의 Script를 P2TR을 통해 실행하고자 한다면, 해당 Script와 관련된 머클 증명 (Hash1, 2, 5, 6)을 Witness에 함께 담아 트랜잭션을 전송하게 된다. 그리고, 해당 트랜잭션을 실행하는 노드는 잠금 스크립트에 있는 <strong>MAST Root</strong>와 Hash Lock에 해당하는 <strong>머클 증명</strong>을 검증하게 되며, 검증에 성공하면 머클 증명에 해당하는 Script가 실행된다.</p><p>하지만, 트랜잭션 작성자가 전체 Script에 구현된 코드와 다른 Script를 실행하고자 한다면, MAST Root 검증 과정에서 트랜잭션은 실패할 것이다. 이처럼 MAST는 Script의 확장성 문제를 해결하며, Script가 분리되더라도 기존 설계대로 정확하게 동작했음을 증명하여 코드의 무결성(Integrity)를 확립한다.</p><h3>마치며</h3><p>이번 아티클에서는 비트코인이 스마트컨트랙트를 구현할 수 없는 이유와 이를 해결하기 위한 Layer 2 솔루션 중 하나인 BitVM에 대해 다루었다. 다음 시리즈인 <strong>‘BitVM: Smarter Bitcoin Smarter (하)’</strong>에서는 BitVM이 어떻게 오프체인에서 스마트컨트랙트를 실행하고, 비트코인 네트워크를 통해 이를 검증하여 신뢰성과 무결성을 유지하는지에 대해 기술적으로 심도 깊게 알아볼 예정이다.</p><p>1부에서 설명한 비트코인의 동작 원리와 Script의 기본 개념, 그리고 Taproot의 Merkelized Alternative Script Tree (MAST)에 대한 지식이 BitVM을 이해하는 데 도움이 되었기를 바라며 이만 글을 마친다.</p><h3>Reference</h3><ul><li><strong>BitVM Whitepaper</strong> : <a href="https://bitvm.org/bitvm.pdf">https://bitvm.org/bitvm.pdf</a></li><li><strong>Locking and Unlocking Scripts in Bitcoin (opengenus) :</strong> <a href="https://iq.opengenus.org/locking-and-unlocking-scripts-in-bitcoin/#google_vignette">https://iq.opengenus.org/locking-and-unlocking-scripts-in-bitcoin/#google_vignette</a></li><li><strong>2017 Mastering Bitcoin</strong> : <a href="https://github.com/bitcoinbook/bitcoinbook/blob/6d1c26e1640ae32b28389d5ae4caf1214c2be7db/BOOK.md">https://github.com/bitcoinbook/bitcoinbook/blob/6d1c26e1640ae32b28389d5ae4caf1214c2be7db/BOOK.md</a></li><li><strong>What Is Segregated Witness (SegWit)? :</strong> <a href="https://river.com/learn/what-is-segwit/">https://river.com/learn/what-is-segwit/</a></li><li><strong>Pay-to-Taproot (P2TR) :</strong> <a href="https://river.com/learn/terms/p/pay-to-taproot-p2tr/">https://river.com/learn/terms/p/pay-to-taproot-p2tr/</a></li><li><strong>Cross-chain Atomic Swaps :</strong> <a href="https://scryptplatform.medium.com/cross-chain-atomic-swaps-f13e874fcaa7">https://scryptplatform.medium.com/cross-chain-atomic-swaps-f13e874fcaa7</a></li><li><strong>co-founder of Stacks Muneeb Ali FAQ :</strong> <a href="https://github.com/stacks-network/stacks/blob/master/stacks-l2.md">https://github.com/stacks-network/stacks/blob/master/stacks-l2.md</a></li><li><strong>Layer 1, Bitcoin Layer 2, or Sidechain? :</strong> <a href="https://trustmachines.co/blog/layer-1-bitcoin-layer-2-stacks/">https://trustmachines.co/blog/layer-1-bitcoin-layer-2-stacks/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf8ae5176042" width="1" height="1" alt=""><hr><p><a href="https://medium.com/decipher-media/bitvm-smarter-bitcoin-smarter-%EC%83%81-cf8ae5176042">BitVM: Smarter Bitcoin Smarter (상)</a> was originally published in <a href="https://medium.com/decipher-media">Decipher Media ｜디사이퍼 미디어</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EIP-1153 : 이더리움의 일시적인 저장 공간 Transient Storage]]></title>
            <link>https://medium.com/@choi_eth/eip-1153-%EC%9D%B4%EB%8D%94%EB%A6%AC%EC%9B%80%EC%9D%98-%EC%9D%BC%EC%8B%9C%EC%A0%81%EC%9D%B8-%EC%A0%80%EC%9E%A5-%EA%B3%B5%EA%B0%84-transient-storage-bb5fce1d932b?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb5fce1d932b</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[dencun-upgrade]]></category>
            <category><![CDATA[eip1153]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Fri, 22 Mar 2024 13:36:17 GMT</pubDate>
            <atom:updated>2024-07-07T12:44:18.723Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deep Dive Into EIP-1153: 이더리움의 일시적인 저장 공간 Transient Storage</h3><blockquote>이더리움의 스마트 컨트랙트는 EVM(Ethereum Virtual Machine) 기반으로 스택(Stack), 메모리(Memory), 스토리지(Storage)와 같은 세 가지 데이터 저장 공간을 사용한다. EIP-1153은 새로운 저장 공간으로 “일시적인 스토리지”, 즉 <strong>Transient storage</strong>를 도입하고, 해당 스토리지에 접근할 수 있는 Opcode를 EVM에 추가함으로써 데이터 처리를 좀 더 효율적으로 수행하고자 하는 내용을 담고 있다.</blockquote><p>EIP-1153는 <a href="https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md#included-eips">칸툰(Cancun) 업그레이드 내역</a>에 포함된 표준(EIP) 중 하나로, 덴쿤(Dancun) 업그레이드를 통해 메인넷에 반영됬다. 그리고 현재 <a href="https://soliditylang.org/blog/2024/01/26/transient-storage/">Solidity 0.8.24</a>에서 transient라는 새로운 저장 공간 태그(Tag)와 EIP-1153에서 주장하는 Opcode를 inline-assembly에 함수로 추가하는 작업까지 마친 상태이다.</p><h3>Transient Storage</h3><p>Transient Storage란 번역 그대로 일시적인 저장 공간이다. 함수가 실행되는 잠시 동안만 데이터를 저장하고 함수 실행이 끝나면 다시 원래 데이터로 되돌아가는 휘발성의 특성을 갖고 있다.</p><h3>Opcode of Transient Storage</h3><p>EIP-1153는 Transient Storage를 제어하기 위해 Opcode TSTORE와 TLOAD를 제시한다. 이더리움 <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/vm/opcodes.go#L121">Github Geth opcode.go</a>를 보면 TSTORE(key,value)는 0x5d, TLOAD(key)는 0x5c라는 Opcode가 추가된것을 확인할 수 있다.</p><p>TSTORE(key,value)는 Transient Storage의 Key 위치에 해당하는 value를 설정(set)하는 기능이다. 스택(stack)에서 최상단 32 bytes의 데이터를 pop하여 데이터가 저장되는 주소값(key)로 사용하고, 스택(stack)에서 그 다음 데이터를 스토리지에 저장하는 value로 사용한다.</p><p>TLOAD(key)는 key 위치의 데이터를 읽어오는 기능을 한다. 마찬가지로 스택(stack)에서 최상단 32 bytes의 데이터를 pop하여 데이터가 저장될 주소값(key)로 사용한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/821/1*Li9T8Tq9amzy24VPRdXxMA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/1*wtZZcmXgn9HqOBi0WNl1uA.png" /><figcaption>[SLOAD &amp; SSTORE] [TLOAD &amp; TSTORE]</figcaption></figure><p>Transient Storage의 구조(Layout)와 동작 방식은 기존의 EVM에 있던 Storage와 완전히 같은 매커니즘을 갖는다. 때문에, 이더리움은 Storage에 접근하기 위한 Opcode SLOAD &amp; SSTORE와 인터페이스를 그대로 Transient Storage에 적용하여 함수를 구현했다. 또한, Geth에 업데이트된 <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/vm/eips.go#L197">TSTORE &amp; TLOAD</a>와 <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/vm/instructions.go#L514">SLOAD &amp; SSTORE</a> 코드를 보면 인터페이스 뿐만 아니라 로직의 동일함 또한 확인할 수 있다.</p><p>EVM이 Storage와 Transient Storage를 동작하는 매커니즘은 동일하지만, 두 저장 공간에 차이점은 “휘발성”이다. Transient Storage는 트랜잭션이 종료되면 원래 데이터로 돌아가지만, Storage는 영구적으로 데이터를 저장한다. 위에 첨부한 Geth의 코드를 보면 <em>StateDB.GetState()</em>와 <em>StateDB.SetState()</em>를 사용하는 SLOAD와 SSTORE와 달리, TLOAD와 TSTORE는 <em>StateDB.GetTransientState()</em>와 <em>StateDB.SetTransientState()</em>를 사용한다.</p><h4>TSTORE : <em>SetTransientState()</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*9JKWfoPvoqA7MWQrsnEXYA.png" /><figcaption>[ <em>StateDB.SetTransientState() ] </em><a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L473">https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L473</a></figcaption></figure><p>Transient Storage에 데이터를 저장하는 TSOTRE 함수 내부의 <em>StateDB.SetTransientState()</em>는 먼저 key에 해당하는 기존의 데이터(prev)를 <em>journal</em>라는 변수에 “뒤쪽 삽입(append)”한다. 만약 prev의 데이터와 새로 저장하려는 value가 같으면 이후의 코드는 따로 수행하지 않는다. 여기서 <em>journal</em>하는 역할은 무엇일까?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*ez3ArASgf2a-zc-I76zg-g.png" /><figcaption>[ journal ] <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/journal.go#L37">https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/journal.go#L37</a></figcaption></figure><blockquote>journal contains the list of state modifications applied since the last state commit. These are tracked to be able to be reverted in the case of an execution exception or request for reversal.</blockquote><blockquote>journal에는 마지막 상태 커밋 이후 적용된 상태 수정 목록이 포함됩니다. 이는 실행 중 예외나 되돌리기 요청이 있을 때 되돌릴 수 있도록 추적됩니다. 예외 또는 되돌리기 요청이 있을 경우 되돌릴 수 있도록 추적됩니다.</blockquote><p>Geth에 나와있는 설명대로 journal은 트랜잭션이 revert 되거나 예외처리(excaption)될 때, storage에 저장된 데이터를 원래 데이터로 되돌리기 위해 일시적으로 캐싱(cache)하는 변수이다. 때문에TSTORE의 <em>StateDB.SetTransientState()</em>가 실행되면 <em>GetTransientState()</em>를 통해 기존의 데이터(prev)를 journal에 저장한 후, <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L488"><em>setTransientState()</em></a>를 통해 새로운 데이터를 Transient Storage에 저장한다.</p><h4>TLOAD : GetTransientState()</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*-tJXfXYo7yWkz903mwMobg.png" /><figcaption>[ GetTransientState() ]<a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L493C19-L493C36">https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L493C19-L493C36</a></figcaption></figure><p>Transient Storage에 저장된 데이터를 조회하는 TLOAD 함수 내부의 <em>StateDB.GetTransientState()</em>는 key에 해당하는 데이터를 불러온다.</p><blockquote><em>Geth에서 Transient Storage의 데이터 자료구조 형태는 가장 깊은 단계의 함수가 구현된 </em><a href="https://github.com/ethereum/go-ethereum/blob/master/core/state/transient_storage.go#L32"><em>transient_Storage.go</em></a><em> 에서 확인할 수 있다.</em></blockquote><h4>Transaction Runtime Function : Execute()</h4><p>EIP-1153이 적용되면서 업데이트된건 TSTORE와 TLOAD 함수 추가뿐만이 아니다. 위에서 언급했던것 처럼 Transient Storage에 저장된 데이터는 트랜잭션이 끝나면 없어지는 휘발성을 갖고 있다. 이런 특성을 적용하기 위해 EVM이 함수를 실행할 때 호출되는 Execute() 또한 수정이 된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1jqnwqdF94-1YK-bROmvEw.png" /><figcaption>[ Execute() ] <a href="https://github.com/ethereum/go-ethereum/blob/2ab365f6d8c51d0e313d5ed30d777e49c7dd1213/core/vm/runtime/runtime.go#L111">https://github.com/ethereum/go-ethereum/blob/2ab365f6d8c51d0e313d5ed30d777e49c7dd1213/core/vm/runtime/runtime.go#L111</a></figcaption></figure><blockquote>Execute executes the code using the input as call data during the execution. It returns the EVM’s return value, the new state and an error if it failed. Execute sets up an in-memory, temporary, environment for the execution of the given code. It makes sure that it’s restored to its original state afterwards.</blockquote><blockquote>Execute()가 실행하는 동안 input으로 받은 Calldata를 사용하여 코드(code)를 실행합니다. Execute()는 EVM으로 부터 받은 반환(return) 값 또는 새 상태(new state), 실패한 경우 오류를 반환(revert)합니다. Execute()는 주어진 코드를 실행하기 위한 인메모리 임시 환경을 설정합니다. 이후에는 원래 상태로 복원되도록 합니다.</blockquote><p>Geth에 나와있는 설명대로 Execute() 함수는 호출하고자 하는 함수의 Calldata를 인자로 받아 함수를 실행한다. 빨간 네모 박스에 있는 <em>state.Prepare() </em>함수 위에 주석을 보면 “reset transient storage(eip 1153)”라고 적혀 있다.</p><h4>state.Prepare()</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rit9dIv7Ywvjd1i7MNuKOw.png" /><figcaption>[ state.Prepare() ] <a href="https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L1314">https://github.com/ethereum/go-ethereum/blob/16ce7bf50fa71c907d1dc6504ed32a9161e71351/core/state/statedb.go#L1314</a></figcaption></figure><blockquote><em>Prepare handles the preparatory steps for executing a state transition with.This method must be invoked before state transition.</em></blockquote><blockquote>Prepare()는 상태 전환을 실행하기 위한 준비 단계를 처리합니다. 이 메서드는 상태 전환 전에 반드시 호출해야 합니다.</blockquote><p>Geth에 주석으로 나와있는 <em>state.Prepare()</em>의 설명을 보면 상태 전환 실행, 즉 트랜잭션을 실행할 때 반드시 호출되는 함수이다. 함수 내부에는 여러 로직이 구현되어 있지만, 빨간 박스에 있는 코드를 보면 Null 상태의 새로운 transient storage를 만들어 저장한다. 이 과정에서 함수가 실행되는 동안 일시적으로 저장된 데이터를 리셋시켜 transient storage의 휘발성을 구현했다.</p><h3>Motivation</h3><p>지금까지 Geth를 통해 EIP-1153에 의해 업데이트된 핵심적인 내용을 다뤄봤다. 이더리움은 기존에 데이터를 저장하고 관리할 수 있는 Storage가 있다. 그럼에도 EIP-1153(transient storage)이 왜 등장하게 되었을까? 이유는 바로 Storage의 지독한 가스비 때문이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-OQGeH6f5ox6Fese3AMy4g.png" /><figcaption><a href="https://ethereum.github.io/yellowpaper/paper.pdf#page=27">https://ethereum.github.io/yellowpaper/paper.pdf#page=27</a></figcaption></figure><p>이더리움의 백서 yellow paper의 27번 페이지를 보면 SSTORE에 대한 가스비가 정의 되어 있다. Storage에 0이 아닌 데이터(non-zero)가 있는 경우 새로운 데이터를 저장할 때 2900 가스비 밖에 안들지만, 만약 0 밖에 없는 텅빈 곳에 새로운 데이터를 저장하는 경우 무려 20000 가스비가 소모된다. 이는 EVM 내 opcode 중에서 높은 수준의 가스를 요구한다.</p><blockquote>TSTORE allows the developer to store 32 bytes for 100 gas, excluding any other required operations to prepare the stack.</blockquote><blockquote>개발자는 스택을 준비하는 데 필요한 다른 작업을 제외하고 100 가스에 대해 32바이트를 저장할 수 있습니다.<br><a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1153.md#security-considerations">https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1153.md#security-considerations</a></blockquote><p>EIP-1153 표준에 나와있는 설명대로, TSTORE는 32 bytes를 저장하는데 100 가스비가 필요하며, 기존의 SSTORE보다 95%나 저렴해졌다.</p><h3>Gas Refund</h3><p>transient storage는 데이터를 일시적으로 저장하고 함수가 종료되면 초기화되는 메커니즘을 갖고 있다. 만약, Storage를 통해 이런 매커니즘을 구현해야한다면, 처음 데이터를 저장할때 20000 가스비가 필요하고 다시 0으로 초기화 할 때 2900의 가스비가 필요하다.</p><p>다행히 이더리움은 블록체인 용량을 최적화하게끔 개발자들에게 동기부여하기 위해, <a href="https://eips.ethereum.org/EIPS/eip-2200">EIP-2200</a>을 통해 가스비 환불(Gas Refund) 제도를 도입한다. Storage에 저장된 데이터를 초기화(0으로 변경)할 때, 최대치를 사용한 가스비의 50%를 다시 돌려준다. 이런 이유로 EIP-1153은 큰 주목을 받지 못했다.</p><p>하지만 일부 사용자들은 이런 가스비 환불 메커니즘을 의도와 다르게 사용하는 사례가 발생한다. 가스 가격이 낮을 때 Storage에 데이터를 저장하고 가스 가격이 높을 때 데이터를 초기화 시켜, 저장할 때 든 가스비보다 더 높은 가스비를 얻는 차익거래(aribtrage)로 사용한 것이다. 이더리움 개발자들은 의도와 다르게 사용되는 사례를 방지하기 위해 <a href="https://eips.ethereum.org/EIPS/eip-3529">EIP-3529</a>를 도입하여 환불 받는 가스비를 50% → 20%로 변경한다. 결국 transient storage와 같이 효율적인 가스비로 일시적으로 데이터를 저장해야하는 기능이 개발자들에게 다시 필요해졌다.</p><h3>EIP-1153 Use Case</h3><p>transient storage처럼 데이터를 일시적으로 저장하고 함수가 종료되면 초기화되는 메커니즘이 스마트 컨트렉트에서 어떤 개발에 활용 될 수 있는지 알아보자. 대표적인 예시가 바로 재진입 공격 방지(Re-entrancy Guard) 패턴이다.</p><pre>// ReEntrancny.sol<br><br>contract ReEntranccy {<br><br>    error ReentrancyGuardReentrantCall();<br><br>    uint256 private status;<br><br>    constructor() {<br>            status = 1;<br>        }<br><br>    modifier nonReentrant() {<br>            _nonReentrantBefore();<br>            _;<br>            _nonReentrantAfter();<br>        }<br><br>    function _nonReentrantBefore() private {<br>        if (status == 2) {<br>            revert ReentrancyGuardReentrantCall();<br>        }<br>        status = 2;<br>    }<br><br>    function _nonReentrantAfter() private {<br>        status = 1;<br>    }<br>}<br><br>contract example is ReEntranccy {<br>    <br>    function transfer(address to, uint256 value) public nonReentrant() {<br>        // ...<br>    }<br>}</pre><p><strong>재진입 공격 방지(Re-entrancy Guard)</strong> 패턴은 하나의 트랜잭션 실행환경(context)에서 컨트랙트 내 특정 함수가 여러번 실행되는 재진입 공격을 방지하는 역할을 수행한다. 동작 방식은 간단하다.</p><p><em>uint256 status</em>는 컨트랙트 Storage Slot에 지정된 변수이다. *<em>modifier nonReentrant()</em>를 함수에 적용하여, 함수가 실행되면 <em>status</em>를 2로 바꾸고 종료되는 시점에 1로 다시 바꾼다. 만약 함수가 종료되지 않은 시점에서 동일한 함수가 다시 호출(재진입)하게 되면 revert()가 발생된다.</p><p>이러한 재진입 공격 방지(Re-entrancy Guard) 패턴은 일시적으로 저장하고 함수가 종료되면 초기화되는 메커니즘을 갖는 transient storage와 동일하다. 다만 EIP-1153이 생기기 전까진 비싼 Storage를 사용하여 구현해야 했다.</p><pre>contract ReEntranccy {<br><br>    modifier nonreentrant {<br>        assembly {<br>            if tload(0) { revert(0, 0) }<br>            tstore(0, 1)<br>        }<br>        _;<br>        // Unlocks the guard, making the pattern composable.<br>        // After the function exits, it can be called again, even in the same transaction.<br>        assembly {<br>            tstore(0, 0)<br>        }<br>    }<br>    <br>    function claimGift() nonreentrant public {<br>      // ...<br>    }<br>}</pre><p><a href="https://soliditylang.org/blog/2024/01/26/transient-storage/">solidity blog</a>에서 재구성한 ReEntranccy는 위와 같다. inline-assembly 내부에서 TSTORE와 TLOAD를 활용하여 기존의 <em>uint256 status</em>를 대체한 모습을 볼 수있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pbvs8xmmJLVknXFTuT2L_w.png" /><figcaption><a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1153.md#motivation">https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1153.md#motivation</a></figcaption></figure><p>EIP-1153로 수혜를 받는건 재진입 공격 방지 패턴뿐만이 아니다. ERC-20의 “(ERC-2612를 활용한) approve pattern”, “Till Pattern”, “Proxy Pattern” 등 기존의 다양한 코드에서 가스비 절감 효과를 받을 수 있다.</p><p>이 처럼 transient storage의 등장으로 최적화 될 수 있는 코드가 다수 존재하기에 EIP-1153는 개발자에게 반가운 소식이 아닐수 없다.</p><h3>Dencum Upgrage</h3><p>EIP-1153은 2018–06–15에 제안된 표준이다. 지금까지 이더리움 메인넷에 반영되지 못하다가 마침내 덴쿤(Dencum) Upgrage에서 메인넷에 적용되기로 결정됬다. 블록에 저장되는 공간 및 데이터를 최적화 시켜 확장성을 향상시키겠다는 덴쿤 업그레이드의 목표에 적합하기 때문이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w8wlEY9YCXkDpIelc721kA.png" /><figcaption><a href="https://chainspect.app/dashboard">https://chainspect.app/dashboard</a></figcaption></figure><p><a href="https://ethereum.org/ko/developers/docs/blocks#block-size">이더리움 공식 문서의 “BLOCK SIZE”에 대한 내용</a>을 보면 블록이 수용할 수 있는 용량은 물리적인 데이터 사이즈가 아닌 소비된 가스양으로 제한한다. 각 블록의 목표 크기는 1,500만 가스이지만, 블록의 크기는 네트워크 수요에 따라 최대 3,000만 가스까지 증가하거나 감소할 수 있다.</p><p>일반적으로 TPS(초당 거래 수)는 블록에 포함된 트랜잭션의 수와 관련되어 있다. 따라서 트랜잭션의 가스비가 줄어들면, 블록에 더 많은 트랜잭션이 포함될 수 있게 되어 TPS가 증가할 것이다. 이는 블록체인 네트워크의 확장성을 향상시키는 요인 중 하나이며 덴쿤 업그레이드 내역에 해당 내용이 포함된 이유이다.</p><h3>마무리</h3><p>기존의 스마트 컨트랙트 개발자들은 Storage를 최소화하고 최적화된 기법을 찾아내기 위해 노력하고 있었다. 따라서 EIP-1153은 이러한 개발자들에게 더욱 개선된 코드를 작성할 수 있는 기회를 제공하며, 이는 이더리움의 사용자 가스비를 저렴하게 만들어주는 효과도 기대해볼 수 있다.</p><h4>Reference</h4><ul><li>EIP-1153 Transient storage opcodes | <a href="https://eips.ethereum.org/EIPS/eip-1153">https://eips.ethereum.org/EIPS/eip-1153</a></li><li>Solidity add TSTORE, TLOAD Opcode on inline-assembly | <a href="https://github.com/ethereum/solidity/pull/14737">https://github.com/ethereum/solidity/pull/14737</a></li><li>Solidity 0.8.24 Blog | <a href="https://soliditylang.org/blog/2024/01/26/transient-storage/">https://soliditylang.org/blog/2024/01/26/transient-storage/</a></li><li>go-ethereum transient_storage.go | <a href="https://www.notion.so/EIP-1153-Transient-Storage-Opcodes-7bc59251db8a48b39907d0412fe5ea20?pvs=4#a6ae7a8bb51d4e838f6496eb68ba4129">https://www.notion.so/EIP-1153-Transient-Storage-Opcodes-7bc59251db8a48b39907d0412fe5ea20?pvs=4#a6ae7a8bb51d4e838f6496eb68ba4129</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb5fce1d932b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[ERC-6551] NFT로 만드는 나만의 지갑 TBA]]></title>
            <link>https://medium.com/@choi_eth/erc-6551-nft%EB%A1%9C-%EB%A7%8C%EB%93%9C%EB%8A%94-%EB%82%98%EB%A7%8C%EC%9D%98-%EC%A7%80%EA%B0%91-tba-a78976f2b7d1?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/a78976f2b7d1</guid>
            <category><![CDATA[erc6551]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[nft]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Mon, 28 Aug 2023 11:57:16 GMT</pubDate>
            <atom:updated>2023-08-29T01:59:38.206Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>본 글은 2023년도 블록체인 학회 Catena Lab에서 ‘NFT로 만드는 나만의 지갑 TBA : ERC-6551’를 주제로 그룹별 발표 진행한 내용을 토대로 작성되었습니다.</blockquote><p><strong>Author<br></strong>Writter : 최원혁(<a href="https://medium.com/u/4858a4819f54">Choi WonHyeok</a>), 신승훈(<a href="https://medium.com/u/3dc3098204c8">Sinsu</a>), 윤태희(<a href="https://medium.com/u/d995347e782a">Jaden Yoon</a>)<br>Published by : Catena Lab (<a href="https://medium.com/u/5e32c2ca74f2">Catena LAB</a>)<br>Reviewed by : 오하영 (<a href="https://medium.com/u/dc7967ed5f37">Hayoung Oh</a>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*Pfrke7yDvTuCOod5K4peGQ.png" /></figure><h3>배경</h3><h4>ERC-6551 이란?</h4><p>ERC-6551은 NFT를 활용하여 Token-bound Account(TBA) 만들기 위한 새로운 표준이다. 이는 ERC-721 그리고 CryptoKitties를 만든 팀의 일원이었던 Benny Giang과 Jayden Windle이 만들었으며 2023년 5월 7일에 이더리움 메인넷에 적용됐다.</p><blockquote>Since ERC721 (NFTs) in 2017, there hasn’t been a major innovation such as 6551. ERC 6551 will truly be the tide that lifts all boats.<em><br></em>2017년 ERC721(NFT) 이후 6551과 같은 큰 혁신은 없었다. ERC 6551은 진정으로 모든 배를 들어 올리는 조류가 될 것입니다. <br>📌 Benny Giang twitter 인용 <a href="https://twitter.com/BennyGiang?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1642221190130593792%7Ctwgr%5E2dd2a33539e6731df2a2c6b8e1d545430caeb63d%7Ctwcon%5Es1_&amp;ref_url=https%3A%2F%2Fwww.coindeskkorea.com%2Fnews%2FarticleView.html%3Fidxno%3D91574">(링크)</a></blockquote><p>CryptoKitties 창립 멤버였던 Benny Giang는 ERC-6551를 NFT를 이은 새로운 혁신이라 표현하고 있으며, 크린토씬에서 많은 공감을 얻는 분위기다. 특히, WEB3 게임 시장과 지갑 플랫폼에서 크게 관심을 갖고 있다. 지금부터 ERC-6551에 대해 알아보자.</p><h3>지갑이란?</h3><p>지갑이란<strong> “0x + 40개의 16진수”</strong>로 이루어진 주소(address) 값을 의미한다. 지금까지 우리에게 지갑은 WEB3 자산(이더, 토큰, NFT 등)을 보관하고 관리하는 용도로 익숙하다. 이러한 규칙을 가진 어떠한 주소 값이라면 코인과 토큰을 보관할 수 있는 지갑이 될 수 있다.</p><h4>개인 지갑 vs 스마트컨트랙트 지갑</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*WO5G-RbAGZQcHQTbYWIoKA.png" /></figure><ul><li><strong>외부 소유 계정(EOA : Externall Owned Accounts)</strong> : 개인키에서 파생된 공개키 주소</li><li><strong>컨트랙트 계정(CA : Contract Accounts)</strong> : 스마트컨트랙트에 부여된 주소</li></ul><p>우리가 블록체인 네트워크로 트랜잭션 보내기 위해 사용하는 지갑은 개인 지갑 또는 외부 소유 계정(EOA)라 하고, 컨트랙트 배포 시 부여되는 주소를 사용하는 지갑은 컨트랙트 계정(CA) 또는 스마트컨트랙트 지갑라고 한다. <br> 개인 지갑은 개인키를 활용한 서명을 통해 트랜잭션을 만들어서 자산을 전송하거나 스마트컨트랙트의 기능을 실행시킬 수 있다. 반면에 스마트컨트랙트 지갑은 개인키가 없기에 서명을 통해 트랜잭션을 만들 수 없다. <strong>때문에 스마트컨트랙트 지갑은 자산을 전송하기 위해서 컨트랙트 내부에 해당 기능을 구현하고 개인 지갑으로 실행하는 방식을 통해 비로소 자산을 관리할 수 있다.</strong></p><h3>Token Bound Account(TBA)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*ELme39nZ9_7iedI-Usm8UQ.png" /><figcaption>Written by Jayden Windle, Benny Giang, Steve Jang, Druzy Downs, Raymond Huynh, Alanah Lam (<a href="https://medium.com/future-primitive/tldr-nfts-have-their-own-wallets-try-it-here-http-tokenbound-org-6fac135a1f9d">Link</a>)</figcaption></figure><p>Token Bound Account(TBA)란 ERC-6551 표준에 따라 만들어진 스마트컨트랙트 지갑을 부르는 명칭이다. 위에서 언급한 것처럼 스마트컨트랙트 지갑은 컨트랙트 내부에 자산을 관리할 수 있는 기능을 구현해야만 한다. 여기서 스마트컨트랙트 지갑은 자산을 관리하는 기능에 지갑의 소유권을 가진 사람만이 제어할 수 있도록 유효성 검사를 구현해야 한다. ERC-6551는 NFT를 소유한 사람이 해당 스마트컨트랙트 지갑의 소유권과 제어권을 가질 수 있도록 설계되었다. 때문에, NFT를 소유한 사람만이 TBA 있는 자산에 접근할 수 있는 구조이다.</p><p>ERC-6551는 단순히 스마트컨트랙트 지갑의 소유권과 제어권을 구현한 것뿐만 아니라, ERC-1167 Minimal Proxy를 활용하여 가스비 측면에서 굉장히 효율적으로 다수의 TBA을 만들 수 있다. 또한, 이미 발행된 NFT를 활용하여 TBA를 만들 수 있기에, 기존에 있던 NFT 프로젝트에 쉽게 적용할 수 있다. 때문에 TBA는 지갑 서비스 측면에서 확장성과 보안성을 모두 갖추고 있으며, NFT를 활용한 새로운 콘텐츠가 등장했다는 평가를 받고 있다.</p><h3>ERC-6551 아키텍처</h3><p>지금부터 NFT, NFT 보유자, 토큰 바운딩 계정 및 레지스트리 간의 관계를 보여주는 다이어그램을 보면서 ERC-6551에 정의된 NFT를 활용하여 TBA를 만드는 방법에 대해 알아보도록 하자.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*xEXRAl7MsyBDt1RQobFBcA.png" /><figcaption>ERC-6551 (<a href="https://eips.ethereum.org/EIPS/eip-6551">Link</a>)</figcaption></figure><h4>Registry Contract</h4><p>누구나 사용할 수 있는 Registry Contract는 일종의 TBA Contract를 생성하는 Factory 역할을 하며, 모든 TBA 주소 쿼리를 위한 단일 진입점 역할이 된다. Registry Contract는 두가지 기능이 있다.</p><ul><li><strong>createAccount</strong><br>implementation 주소가 주어진 NFT에 대한 TBA을 생성한다.</li><li><strong>account</strong> <br>implementation 주소가 주어진 NFT에 대한 TBA 주소를 계산한다.</li></ul><h4>EIP-721 Contract(NFT 표준)</h4><p>ERC-6551에선 기존의 ERC-721 컨트랙트와의 역 호환성을 최대한 확보하려고 노력했다. 따라서 ERC-721 표준을 확장하지 않고 기존 표준에 바인딩하는 방식을 채택했다.<br>EIP-721 표준으로 생성한 NFT와 바인딩해 TBA에 소유권을 갖고, 한 개의 NFT는 여러 개에 TBA를 소유할 수 있는 구조이다.</p><h4>Account(TBA) Contract</h4><p>Account Contract는 Registry contract에 <em>createAccount</em> 함수를 통해 생성된 ERC-1167 Minimal Proxy Contract이다.<br>Account Contract는 한번 바인딩된 ERC-721의 Owner만 호출할 수 있고, 다른 NFT로 변경할 수 없는 특징이 있다.</p><h4>Implementation Contract(Logic Contract)</h4><p>Implemantation Contract는 TBA의 기능에서 중요한 역할을 한다. 현재 TBA에서 사용할 수 있는 일련의 기능을 정의하여 몇 가지 주요 작업을 수행할 수 있다. 예를 들어, <strong><em>receive()</em></strong> 기능을 통해 TBA는 Ether를 수신할 수 있고 TBA가 NFT 소유자를 대신하여 임의의 호출을 실행할 수 있는 강력한 기능인 <strong><em>“executeCall”</em></strong>기능을 사용할 수 있다. 또한 소유자에게 실행 권한을 부여하는 방법을 제공한다.</p><h3>ERC-6551 with ERC-1167(Minimal Proxy)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-SWAO8A1SRGIkqxVNqzRcw.png" /></figure><p>ERC-1167의 Minimal Proxy는 완전히 동일한 로직을 갖는 컨트랙트를 여러 번 배포해야 하는 경우, 배포 비용을 최적화하기 위해 등장한 표준이다. 표준에서 정의한 Minimal Proxy는 위와 같은 아키텍처를 통해 3가지 단계로 구성되어 있다.<br>Factory Contract와 Logic Contract를 배포한 후, Factory에서 Minimal Proxy Contract를 배포한다. 그리고, Minimal Proxy Contract는 프록시 패턴을 통해 Logic Contract에 구현된 함수를 사용한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*-vBki2iTrF0kKNE6Ea3_Og.png" /></figure><p>ERC-6551의 아키텍처에서 설명했던 Registry, Account(TBA), Implementation 모두 전반적으로 ERC-1167 표준의 Minimal Proxy를 활용한다. Minimal Proxy가 ERC-6551의 아키텍처에서 어떻게 활용되었는지 알아보자.</p><h4>ERC-6551 Account(TBA) with Minimal Proxy</h4><p>Minimal Proxy는 컨트랙트 배포의 최적화를 위해 등장했다. 때문에 <strong><em>“Minimal Proxy”</em></strong> 말 그대로 <strong><em>“최소한의 기능만 구현된 컨트랙트”</em></strong>를 의미한다. 여기서 말하는 “최소한의 기능”은<strong><em> “이미 체인 어딘가에 배포된 컨트랙트를 프록시 패턴을 통해 호출하는 기능”</em></strong>을 말한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*fKNsU6D805rnhkuWC0yV3A.png" /><figcaption>출처 Openzeppelin Blog(<a href="https://blog.openzeppelin.com/proxy-patterns">링크</a>)</figcaption></figure><p>프록시 패턴(Proxy Pattern)는 그림처럼 사용자가 프록시 컨트랙트로 어떠한 함수를 호출하면, 프록시 컨트랙트는 로직 컨트랙트로 호출을 넘겨 로직 컨트랙트의 함수를 호출한다. 이때, 프록시 컨트랙트는 로직 컨트랙트의 함수만 호출하고, 저장해야 하는 데이터, 최종 리턴값(return), 실행환경(msg.sender, msg.data 등등..)은 프록시 컨트랙트에 저장된다.</p><pre>// SPDX-License-Identifier: MIT<br>pragma solidity ^0.8.17;<br><br>contract MinimalProxy {<br> address constant logicContract = &quot;0xbebebebebebebebebebebebebebebebebebebebe&quot;;<br><br> function delegate() external returns (bytes memory) {<br>  (bool success, bytes memory data) = logicContract.delegatecall(msg.data);<br>  require(success);<br><br>  return data;<br> }<br>}</pre><p>프록시 패턴(Proxy Pattern)은 위와 같이Solidity의 <strong>delegatecall</strong>을 활용하여 구현된다. 유저는 Logic Contract에서 호출하고자 하는 함수의 <strong>calldata(msg.data)</strong>를 delegate() 함수의 delegatecall을 통해 호출할 수 있다.</p><p><strong>Minimal Proxy</strong>를 구현하는 코드는 위 내용이 전부이다. 말 그대로 <strong><em>“최소한의 기능”</em></strong>으로, 로직 컨트랙트로 delegatecall을 하는게 전부이다. 하지만 Minimal Proxy는 코드를 극단적으로 최적화하기 위해 동일한 기능을 수행하는 로직을 EVM 바이트 코드로 구현했다. ERC-1167에서 정의한 실제 Minimal Proxy 코드는 아래와 같다.</p><p><strong><em>3d602d80600a3d3981f3363d3d373d3d3d363d73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3</em></strong></p><blockquote>📌 Solidity로 구현된 예시 코드를 컴파일한다고 해서 위와 같은 바이트코드로 변환되지 않는다. 예시 코드는 단지 바이트코드로 되어있는 코드를 이해하기 쉽게 구현한 예시일 뿐이다.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*pUGaxmtwVx_XiusiFfKQXg.png" /><figcaption>ERC-1167에서 정의한 바이트코드는 두 가지 역할로 분리할 수 있다.</figcaption></figure><p><strong>🔍 Creation Code</strong><br>Creation Code는 Init Code라고도 불리며 컨트랙트를 배포하기 위해 필요한 코드이다. 배포 후에 따로 저장되지는 않는다.</p><p><strong>🔍 Runtime Code</strong><br>Runtime Code는 실제 사용자가 컨트랙트로 어떤 함수를 호출할 때 동작하는 코드이다. Minimial Proxy에서 구현한 Runtime Code는 Logic Contract로 delegatecall을 보내는 기능을 갖고 있다.</p><p>ERC-6551의 Account(TBA) 는 ERC-1167에서 정의한 Minimal Proxy 코드로 구현되어 있다. 때문에 코드 사이즈가 굉장히 작아 스마트컨트렉트 지갑(TBA)을 만드는데 아주 작은 가스비가 소모된다.</p><h4>ERC-6551 Registry with Minimal Proxy Factory</h4><p>Minimal Proxy Factory는 factory pattern으로 구현되었으며, Minimal Proxy Contract를 여러 개 배포할 수 기능을 가진 컨트랙트이다. ERC-6551은 같은 기능을 가진 TBA를 여러 개 배포할 때, 필요한 비용을 최적화하기 위해 Minimal Proxy Factory를 Registry에 적용했다.</p><blockquote><strong><em>❓factory pattern<br></em></strong><em>스마트 컨트렉트는 배포하기 위해 트랜잭션을 작성하여 블록체인으로 전송한다. 하지만 Factory Pattern을 활용하면 Solidity를 통해 컨트랙트 내부에서도 컨트랙트를 배포할 수 있는 기능을 만들 수 있다. <br>factory pattern는 Solidity의 new 연산자를 통해 구현할 수 있지만, inline-assembly의 CREATE 또는 CREATE2를 활용하여 더욱 최적화된 코드로 구현할 수 있다. OpenZeppelin의 </em><a href="https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Clones.sol"><em>Clone.sol</em></a><em>에서는 Minimal Proxy Factory를 inline-assembly의 CREATE 또는 CREATE2를 통해 구현했다.</em></blockquote><pre>function createAccount(<br>        address implementation,<br>        uint256 chainId,<br>        address tokenContract,<br>        uint256 tokenId,<br>        uint256 salt,<br>        bytes calldata initData<br>    ) external returns (address) {<br>        bytes memory code = _creationCode(implementation, chainId, tokenContract, tokenId, salt);<br><br>        address _account = Create2.computeAddress(<br>            bytes32(salt),<br>            keccak256(code)<br>        );<br><br>        if (_account.code.length != 0) return _account;<br><br>        _account = Create2.deploy(0, bytes32(salt), code);<br><br>        if (initData.length != 0) {<br>            (bool success, ) = _account.call(initData);<br>            if (!success) revert InitializationFailed();<br>        }<br><br>        emit AccountCreated(<br>            _account,<br>            implementation,<br>            chainId,<br>            tokenContract,<br>            tokenId,<br>            salt<br>        );<br><br>        return _account;<br>    }<br><br>function _creationCode(<br>        address implementation_,<br>        uint256 chainId_,<br>        address tokenContract_,<br>        uint256 tokenId_,<br>        uint256 salt_<br>    ) internal pure returns (bytes memory) {<br>        return<br>            abi.encodePacked(<br>                hex&quot;3d60ad80600a3d3981f3363d3d373d3d3d363d73&quot;,<br>                implementation_,<br>                hex&quot;5af43d82803e903d91602b57fd5bf3&quot;,<br>                abi.encode(salt_, chainId_, tokenContract_, tokenId_)<br>            );<br>    }</pre><p>ERC6551의 Registry 또한 inline-assembly의 CREATE 또는 CREATE2를 활용한다. Registry를 통해 TBA를 배포하게되면 컨트랙트의 바이트코드는 위와 같이 되어 있다. _creationCode()함수의 파라미터를 보면 NFT의 정보와 implementation(Logic) contract의 주소를 받는다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*AFoMId8q9buPEiPO0qIDEg.png" /><figcaption>TBA Contract 바이트 코드</figcaption></figure><p>_creationCode() 는 파라미터를 통해 Minimal Proxy의 바이트 코드를 만드는 역할을 한다. abi.encode(salt,chainId,tokenContract,tokenId) 이전까지는 Minimal Proxy의 바이트 코드와 일치하지만, ERC6551은 바이트코드 마지막에 NFT의 정보를 붙혀서 컨트랙트를 배포한다.</p><p>_creationCode() 함수로 생성된 TBA의 바이트코드는 createAccount() 함수를 통해 컨트랙트가 배포된다. 컨트랙트가 배포되면, 바이트코드는 스마트컨트렉트의 Codehash 라는 공간에 저장된다.<br>TBA는 NFT의 소유주만 접근할 수 있도록 설계된 스마트컨트렉트 지갑이다. Codehash에 저장된 NFT의 정보는 전송(transfer), 입금(deposit)과 같은 지갑의 기능을 호출할 때, NFT의 소유주만 호출할 수 있도록 유호성 검사를 위해 활용된다. 해당 내용은 아래 ERC-6551의 Logic Contract에서 자세히 다뤄보겠다.</p><h4>ERC-6551 Implementation with Logic Contract</h4><p>스마트컨트렉트 지갑은 컨트랙트 내부에 전송(transfer), 잔액 조회와 같은 자산을 관리할 수 있는 기능이 구현되어 있어야지만 비로소 스마트컨트렉트 지갑이라고 할 수 있다. 또한, 스마트컨트랙트 지갑의 자산을 관리하는 기능에 지갑의 제어권을 가진 사람만이 제어할 수 있도록 코드를 구현해야 한다. <br>때문에 ERC-6551는 TBA에 필요한 기능을 Logic Contract(Implementation)에 구현했다.</p><h4><strong>🔍 지갑 기능 구현</strong></h4><p>기본적으로 지갑은 전송(transfer) 기능이 있어야한다. 하지만 스마트컨트렉트 지갑은 여러가지 표준(ERC20, ERC721, ERC1155 등등…)에 맞는 모든 기능을 구현해야만 한다. 모든 기능을 함수로 하나하나 코딩하면 되지만, 혹시나 필요한 기능을 구현하지 못한다면, 기존의 TBA는 버리고 다시 배포하여 새로운 Logic Contract로 연결해야한다.<br><strong>이러한 문제점을 해결하기 위해 ERC-6551은 모든 함수를 TBA에서 호출할 수 있는 기능을 Solidity의 </strong><strong>call()을 통해 구현했다.</strong></p><pre>uint256 public nonce;<br><br>function executeCall(<br>        address to,<br>        uint256 value,<br>        bytes calldata data<br>    ) external payable returns (bytes memory result) {<br>        require(msg.sender == owner(), &quot;Not token owner&quot;);<br><br>        ++nonce;<br><br>        emit TransactionExecuted(to, value, data);<br><br>        bool success;<br>        (success, result) = to.call{value: value}(data);<br><br>        if (!success) {<br>            assembly {<br>                revert(add(result, 32), mload(result))<br>            }<br>        }<br>    }</pre><p>블록체인은 크게 3가지 요청을 받아 동작한다. (스마트컨트렉트 배포 요청은 제외)</p><ol><li><strong>이더 전송</strong></li><li><strong>스마트컨트렉트 함수 호출</strong></li><li><strong>이더 전송 + 스마트컨트렉트 함수 호출</strong></li></ol><p>위 3가지 요청을 위해 사용자는 Off-Chain에서 트랜잭션을 작성하여 블록체인에 전달한다. 하지만 Solidty의 Call() 함수를 사용하면 스마트컨트렉트 내부에서도 위 3가지 요청을 보낼 수 있다. <br>executeCall()는 3가지 파라미터를 받는다. 요청하고자 하는 동작에 따라 필요한 데이터를 파라미터에 담아 호출하면 된다.</p><ol><li><strong>이더 전송</strong><br>이더를 받는 사람의 주소를 to, 전송하고자 하는 ether를 value에 넣으면 된다. 여기서 data는 스마트컨트렉트를 호출하기 위한 데이터이다. 지금은 이더 전송만 하기에 data에 0x0을 넣어주면 된다.</li><li><strong>스마트컨트렉트 함수 호출</strong><br>호출하고자하는 스마트컨트렉트의 주소를 to, 호출하고자하는 함수의 Calldata를 data에 넣으면 된다. 이더를 전송하지 않으니, value에 0을 넣어주면 된다.</li><li><strong>이더 전송 + 스마트컨트렉트 함수 호출</strong><br>호출하고자 하는 스마트컨트렉트의 주소를 to, 호출하고자하는 함수의 Calldata를 data, 전송하고자 하는 ether를 value에 넣으면 된다. 함수 호출과 이더 전송을 같이 하는 경우는, 사람이 아닌 스마트컨트렉트로 이더를 전송하는 것이다.</li></ol><p>TBA는 위와 같이 <strong>to.call{value: value}(data) </strong>코드로 스마트컨트랙트 지갑을 통해 블록체인에 필요한 모든 요청을 보낼 수 있다. ERC-6551은 이를 통해 지갑 기능의 범용성을 구현했다.</p><h4><strong>🔍 접근 제어(Access Control)</strong></h4><p>executeCall() 함수를 통해 TBA에 있는 자산을 전송하고 관리하는 기능을 구현했다. 스마트컨트렉트는 탈중앙화 특성 상, 누구든지 접근이 가능하기에 executeCall()을 TBA의 주인만 실행할 수 있도록 구현해야한다.</p><pre>... <br>require(msg.sender == owner(), &quot;Not token owner&quot;);<br>...</pre><p>TBA는 위와 같은 코드로 executeCall() 함수에 제어권을 가진 주인(owner)만이 호출할 수 있도록 접근 제어 로직을 구현했다. 지금까지 설명이 길어서 잊었을 수 있지만, TBA는 홀더의 NFT 정보를 통해 만들어진다. 여기서 owner()는 현재 NFT의 홀더의 주소를 리턴한다.</p><pre>function token()<br>    internal<br>    view<br>    returns (<br>        uint256,<br>        address,<br>        uint256<br>    )<br>{<br>    bytes memory footer = new bytes(0x60);<br>    assembly {<br>        // copy 0x60 bytes from end of footer<br>        extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)<br>    }<br><br>    return abi.decode(footer, (uint256, address, uint256));<br>}<br><br>function owner() public view returns (address) {<br>    (uint256 chainId, address tokenContract, uint256 tokenId) = this.token();<br>    if (chainId != block.chainid) return address(0);<br><br>    return IERC721(tokenContract).ownerOf(tokenId);<br>}</pre><p>ERC-6551에서 Owner의 NFT 정보를 통해 홀더의 주소를 리턴하는 로직은 위와 같다.<br>token() 함수의 inline- assembly 내부에서 사용된 [<a href="https://ethervm.io/#3C"><em>EXTCODECOPY</em></a>]는 컨트랙트의 Codehash에 저장된 bytecode를 불러오는 기능을 갖고 있다. TBA는 ERC-6551 Registry를 통해 배포할 때, NFT의 정보는 바이트코드 마지막에 붙어서 저장된다. ERC-6551은 token() 를 통해 NFT의 정보를 가져오고, 가져온 정보를 통해owner() 함수의 IERC721(tokenContract).ownerOf(tokenId) 를 호출한다. ERC721의 ownerOf() 를 통해 NFT의 소유주 주소를 조회하여, 소유주만이 기능을 호출할 수 있도록 지갑의 접근 제어 검사를 구현했다.</p><p>이를 통해 TBA는 NFT의 소유주만 접근할 수 있는 스마트컨트렉트 지갑을 설계했다.</p><h3>ERC-6551 실습</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F7jYKWwaYjcE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D7jYKWwaYjcE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F7jYKWwaYjcE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ab71228be10e269c94409c4ba27db830/href">https://medium.com/media/ab71228be10e269c94409c4ba27db830/href</a></iframe><p>더 쉬운 이해를 위해, 같이 주제를 조사했던 신승훈님께서 시연 영상을 촬영하여 만들어 주셨다. 해당 실습은 Pinata에서 만든 코드를 참고하여 진행되었다. 전체 코드와 함께 보면서 이해가 더욱 잘 될것이다.<br><strong>[ Youtube (3분) ]</strong> : <a href="https://www.youtube.com/watch?v=7jYKWwaYjcE">https://www.youtube.com/watch?v=7jYKWwaYjcE</a><br><strong>[ Pinata Github ]</strong> : <a href="https://github.com/kk-im/tba-tutorial-pinata">https://github.com/kk-im/tba-tutorial-pinata</a></p><h3>TBA로 어떤것을 할 수 있을까?</h3><h4>(1) Web3 게임 속 인벤토리 활용</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hvlHkAf8KyV1i0qa-UfvBQ.png" /><figcaption>출처: <a href="https://blog.thirdweb.com/erc-6551-token-bound-accounts/">https://blog.thirdweb.com/erc-6551-token-bound-accounts/</a></figcaption></figure><p>ERC-6551 이전에는 NFT로 자신의 캐릭터를 소유할 수는 있었지만 게임 내에서 수집한 모든 관련 자산은 소유자의 지갑에 별도의 토큰으로 보관했어야 했다. 하지만 TBA를 게임 속 인벤토리로 활용해 모든 게임 관련 자산을 TBA에 보관해 더 나은 사용자 경험을 제공하고 구현하기 어려웠던 게임 내 UI를 사용할 수 있게 됐다. <br>또 단순히 인벤토리로 아이템 및 자산을 홀딩하는 것뿐만 아니라 <strong>인벤토리 자체를 판매하거나 이동</strong>할 수도 있다.</p><h4>(2) 자산에 대한 쉬운 지갑 전환</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*uvokOJkpAGFC81f9UFVCYA.png" /><figcaption>출처: <a href="https://blog.thirdweb.com/erc-6551-token-bound-accounts/">https://blog.thirdweb.com/erc-6551-token-bound-accounts/</a></figcaption></figure><p>소유자의 지갑에 보관되어있던 토큰, 자산 및 NFT를 단일 TBA로 결합한 상태로 보관하면 사용자가 자산을 전송하고 플랫폼을 쉽게 전환할 수 있다. (NFT 이동 한번으로 모든 자산 이동 가능)</p><p><strong>1. 나의 자산에 대한 보안 주기 설정 가능<br>2. 디파이와 같이 예치된 자산에 대한 지갑 전환이</strong></p><p>기존에는 보유한 자산을 하나의 지갑으로 보관했기 때문에 지갑을 변경한다 하더라도 모든 자산을 일일이 옮겨야 됬기 때문에 상당히 힘든 일이 였다. 하지만 TBA를 활용하면 단 한번의 이동으로 나의 자산을 안전하게 옮길 수 있다.</p><h4><strong>(3) 무궁무진한 활용가치</strong></h4><p>현재 커뮤니티에선 ERC-6551의 TBA를 무궁무진한 활용가치를 가진 새로운 컨텐츠라고 판단하고 많은 연구가 이뤄지고 있다.</p><p>ERC-6551는 현재 ERC-721로만 토큰 바운딩 계정을 생성하지만 ERC-1155를 활용하면 보다 다양한 분야에서 활용할 수 있다. ERC-1155로 토큰 바운딩 계정을 생성하면 소유권이 분산된 공유 지갑형태를 만들 어 다양한 분야에서 사용될 수 있다.</p><ol><li>TBA에 스테이블 코인이 예치되고 결제 시스템까지 구현된다면 법인카드 형태 가능</li><li>게임에서도 파티원들과 같이 사용하는 공유 인벤토리로 활용 가능</li><li>토큰에 개수로 해당 지갑에 지분을 나타내 DAO 거버넌스 투표처럼 투표를 통해 과반수가 넘어야만 자산이 이동되게 구현할 수 있음(DAO 자금 운영을 조금 더 DAO스럽게 할 수 있음)</li></ol><h3>ERC-6551의 한계점</h3><ol><li>ERC-6551은 모든 NFT 유형을 지원하지 않는 점에서 한계를 가지고 있다. 랩드 버전의 ERC-721만 호환되며, 따라서 사전에 호환성 검토하는 것이 중요하다. 더불어, 초기 단계의 프로젝트로 인한 생태계 지원 부족 또한 이슈로 작용하고 있다. 또한, 기존 프로젝트나 플랫폼과의 충돌 가능성이 존재한다.</li><li>다음으로는 보안 상의 위험이 높아질 수 있다. NFT의 가치가 높아진다는 것은 해커들이 공격하기에 더 매력적이라는 것을 의미하며, 안전을 보장하면서도 더 높은 가치의 자산을 사용하기 위해서는 보다 엄격하고 체계적인 보안 검토가 요구된다.</li><li>마지막으로 사용자 경험 측면에서는, 아직까지 ERC-6551은 아직 많은 사용자를 확보하지 못했기 때문에 사용자 피드백이 거의 없는 상태이다. 향후 더 많은 사용자 확보를 위한 직관적인 프로세스 및 인터페이스 개발이 필요하다.</li></ol><h3>마무리</h3><p>현재, 블록체인의 대세 키워드는 <strong>“지갑”</strong>이다. 사용자들이 접근하기 쉽고 사용하기 좋은 지갑을 먼저 개발하는 사업이 블록체인에서 큰 주목을 받을 거라는 전망을 갖고 있기 때문이다. 이러한 이유로 ERC-6551은 NFT의 고유정보를 활용하여 소유권과 제어권을 가지는 <strong>스마트컨트렉트 지갑</strong> 이라는 부분에서 굉장히 주목을 받고 있는것 같다.<br>때문에 TBA는 NFT를 활용한 더 다양한 컨텐츠를 만들어 낼 수 있는 발판이 될 것이라고 조심스럽게 예상해보며 더욱 다양한 WEB3 콘텐츠가 탄생하길 기대하며 이만 글을 마친다.</p><h3>Reference</h3><ul><li><a href="https://eips.ethereum.org/EIPS/eip-6551"><strong>[Ethereum Improvement Proposals] ERC-6551: Non-fungible Token Bound Accounts</strong></a></li><li><a href="https://www.pinata.cloud/blog/a-new-era-erc-6551-and-token-bound-accounts-tbas"><strong>[Pinata Blog] A New Era: ERC-6551 and Token-Bound Accounts (TBAs)</strong></a></li><li><a href="https://github.com/kk-im/tba-tutorial-pinata"><strong>[Pinata TBA Tutorial] Create An ERC-6551 Tokenbound Account with an ERC-721 NFT</strong></a></li><li><a href="https://medium.com/@bornTo_Dev/deep-dive-into-%EB%AF%B8%EB%8B%88%EB%A9%80-%ED%94%84%EB%A1%9D%EC%8B%9C-minimal-proxy-erc-1167-403fd1eb571b"><strong>[Medium] Deep Dive Into ERC-1167 : 미니멀 프록시(Minimal Proxy)</strong></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a78976f2b7d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deep Dive into ERC-1271 : 스마트컨트랙트 지갑 서명 유효성 검사]]></title>
            <link>https://medium.com/@choi_eth/deep-dive-into-erc-1271-%EC%8A%A4%EB%A7%88%ED%8A%B8%EC%BB%A8%ED%8A%B8%EB%9E%99%ED%8A%B8-%EC%A7%80%EA%B0%91-%EC%84%9C%EB%AA%85-%EC%9C%A0%ED%9A%A8%EC%84%B1-%EA%B2%80%EC%82%AC-c77eddb46a?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/c77eddb46a</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[erc-1271]]></category>
            <category><![CDATA[smart-contract-blockchain]]></category>
            <category><![CDATA[solidity]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Mon, 14 Aug 2023 15:38:03 GMT</pubDate>
            <atom:updated>2024-03-22T14:15:10.067Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deep Dive into ERC-1271 : 스마트컨트랙트 지갑 서명 유효성 검사</h3><h3>Author</h3><ul><li>최원혁(<a href="https://medium.com/u/4858a4819f54">Choi WonHyeok</a>)</li></ul><h3>Intro</h3><p>외부 소유 계정(EOA)은 보유 중인 개인 키로 메시지에 서명할 수 있지만, 컨트랙트 계정(CA)은 개인키를 알 수 없기에 불가능하다. ERC-1271는 특정 스마트 컨트랙트 지갑을 대신한 서명이 유효한지 확인할 수 있는 표준 방법을 제안한다.</p><p>본 게시글은 서명을 할 수 없는 스마트 컨트랙트 지갑을 위해 대신한 서명과 해당 서명의 유효성을 어떻게 확인하는지에 대해 다루고 있다. 지금부터 ERC-1271에 대해 알아보자.</p><h3>개인 지갑 vs 스마트컨트랙트 지갑</h3><p>ERC-1271에 대해 알아보기 전에 <strong>개인 지갑</strong>과 <strong>스마트컨트랙트 지갑</strong>의 차이점에 대해 알아보자. 지갑이란 <strong>0x + 40개의 16진수</strong>로 이루어진 주소(address) 값을 의미한다. 지금까지 우리에게 지갑은 WEB3 자산(이더, 토큰, NFT 등)을 보관하고 관리하는 용도로 익숙하다. 이러한 규칙을 가진 어떠한 주소 값이라면 코인과 토큰을 보관할 수 있는 지갑이 될 수 있다.</p><ul><li>외부 소유 계정(EOA : Externall Owned Accounts) : 개인키에서 파생된 공개키 주소</li><li>컨트랙트 계정(CA : Contract Accounts) : 스마트컨트랙트에 부여된 주소</li></ul><p>우리가 블록체인 네트워크로 트랜잭션 보내기 위해 사용하는 지갑은 <strong>개인 지갑</strong> 또는 <strong>외부 소유 계정(EOA)</strong>라 하고, 컨트랙트 배포 시 부여되는 주소로 사용하는 지갑은 <strong>컨트랙트 계정(CA)</strong> 또는 <strong>스마트컨트랙트 지갑</strong>라고 한다.</p><p>개인 지갑은 개인키를 활용한 서명을 통해 트랜잭션을 만들어서 자산을 전송하거나 스마트컨트랙트의 기능을 실행시킬 수 있다. 반면에 스마트컨트랙트 지갑은 개인키가 없기에 서명을 통해 트랜잭션을 만들 수 없다. 때문에 스마트컨트랙트 지갑은 자산을 전송하기 위해서 컨트랙트 내부에 해당 기능을 구현하고 개인 지갑으로 실행하는 방식을 통해 비로소 자산을 관리할 수 있다.</p><h3>디지털 서명의 3가지 용도</h3><p>이더리움에서 사용하는 디지털 서명은 3가지 용도를 위해 사용한다.</p><ol><li>서명은 EOA와 개인키 소유자가 트랜잭션 이행을 <strong>승인했음</strong>을 증명한다.</li><li>승인했음에 대한 <strong>부인방지(non-reudiation)</strong>를 보장한다.</li><li>트랜잭션이 서명된 후에는 그 누구도 트랜잭션 데이터를 <strong>수정할 수 없음</strong>을 증명한다.</li></ol><p>우리는 위 3가지 용도를 통해서 지갑에 대한 소유권을 주장할 수 있다. 특히 이더리움의 디지털 서명은 <strong>ECDSA(Eliptic Curve Digital Signature Algorithm)의 타원 곡선 알고리즘을 사용하기에, 개인키를 노출하지 않고 해당 지갑 주소에 대한 소유권을 주장할 수 있다.</strong> 하지만 스마트컨트랙트 지갑은 개인키가 없어서 소유권을 주장할 수 없다. 이러한 한계에 대한 대응책으로 <strong>ERC-1271</strong>은 스마트컨트랙트 지갑을 위해, <strong>“직접 만드는 서명”</strong>이 아닌 특별히 맞춤화된 새로운 <strong>“서명 검증 방식”</strong>을 제안하며 등장했다. ERC-1271은 지갑의 소유권을 가진 사람의 서명을 검증하는 방식을 통해 Off-Chain 영역에서 스마트컨트랙트 지갑에 대한 소유권을 주장할 수 있다.</p><h3>ERC-1271 Specification</h3><p>ERC-1271은 지갑이(account) 스마트컨트랙트 지갑인 경우, 지갑의 소유권을 가진 사람이 본인의 개인키로 만든 서명을 통해 스마트컨트랙트 지갑의 소유주임을 확인하는 방법이 표준으로 정의되어 있다. 코드 레벨에서 알아보자.</p><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.10;<br>import &quot;@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol&quot;;<br>import &quot;@openzeppelin/contracts/interfaces/IERC1271.sol&quot;;<br><br>contract ERC1271 is IERC1271 {<br>    address private _owner;<br><br>    constructor(address owner) {<br>        _owner = owner;<br>    }<br><br>    function owner() public view returns(address) {<br>        return _owner;<br>    }<br><br>    function isValidSignature(bytes32 hash, bytes memory signature)<br>            external<br>            view<br>            returns (bytes4 magicValue)<br>        {<br>            bool isValid = SignatureChecker.isValidSignatureNow(owner(), hash, signature);<br><br>            if (isValid) {<br>                return IERC1271.isValidSignature.selector;<br>            }<br><br>            return &quot;&quot;;<br>        }<br>}</pre><p><a href="https://github.com/imelon2/solidity/blob/main/contracts/ERC1271/ERC1271.sol">solidity/contracts/ERC1271/ERC1271.sol at main · imelon2/solidity</a></p><p>기능은 아주 간단하다. 지갑의 소유권을 가진 주인(Owner)이 서명한 <strong>메시지(hash)</strong>와 <strong>서명 값(signature)</strong>을 isValidSignature()의 파라미터에 담아서 보내면 끝이다. 서명값과 메시지를 검증하여 스마트컨트렉트 지갑의 owner임이 검증되면, 서명한 사람이 해당 지갑을 소유하고 있음을 증명할 수 있다. 그리고 증명이 성공하게 되면 0x1626ba7e(=bytes4(keccak256(&quot;isValidSignature(bytes32,bytes)&quot;))을 리턴한다.</p><p>만약, 소유주가 아닌 사람이 만든 서명값을 통해 isValidSignature()하게 되면 서명 검증은 실패하며 빈 문자열을 리턴한다. 이와 같은 EIP-1271을 통해, 개인키를 공개하지 않고, 스마트컨트렉트 지갑의 소유권을 Off-Chain상에서 주장할 수 있다.</p><h3>메시지 서명 만들기 by.ethers</h3><p>EIP-1271 isValidSignature()의 파라미터에 들어가는 메시지(hash)와 서명 값(signature)을 ethers를 활용하여 만들어보자.</p><p><a href="https://github.com/imelon2/solidity/blob/main/scripts/signERC1271.ts">solidity/scripts/signERC1271.ts at main · imelon2/solidity</a></p><h4><strong>🔍 STEP 1 : 메시지 데이터 타입 변환</strong></h4><p>일반적으로 서명하는 메시지의 데이터타입은 문자열(String)이지만, isValidSignature() 파라미터의 메시지 데이터 타입은 bytes32로 되어 있다. 때문에 서명하고자 하는 메시지를 bytes32로 변환해야 한다. 이를 위해 가장 쉬운 방법은 keccak256() 해쉬함수를 통해 변환시키는 것이다.</p><pre>import {ethers} from &#39;ethers&#39;;<br><br>const MSG = &quot;This is MSG for EIP-1271&quot;<br><br>let _hash = ethers.utils.toUtf8Bytes(MSG);<br>let hash = ethers.utils.keccak256(_hash)</pre><blockquote>작성하고자 하는 메시지는 어떠한 내용이 들어가도 상관없다. 어차피 서명은 내가 가진 개인키로 진행되기 때문에, 내용을 떠나서 디지털 서명을 통해 소유권을 가진 사람이 서명한 게 맞는지를 증명하기만 하면 된다.</blockquote><p>keccak256() 해쉬함수는 bytes 형태의 데이터만 변환시키기에, <br>문자열을 먼저 bytes로 변환한 후, 암호화를 시켜 bytes32로 변환시켰다.</p><h4><strong>🔍 STEP 2 : 서명</strong></h4><pre>const signer = new ethers.Wallet(process.env.ADMIN_KEY);<br><br>let signature = signer._signingKey().signDigest(hash)<br>console.log(&quot;sig.v:&quot; + signature.v);<br>console.log(&quot;sig.r: &quot; + signature.r);<br>console.log(&quot;sig.s: &quot; + signature.s);<br><br>let data = {<br>        r:signature.r,<br>        s:signature.s,<br>        v:signature.v<br>    }<br><br>let _signature = ethers.utils.joinSignature(data);<br>console.log(`_signature : ${_signature}`);</pre><p>isValidSignature()의 서명값(signature)은 서명 데이터 v,r,s를 합친 bytes의 형태다. keccak256로 해싱된 메시지를 서명하여 만든 서명값 v,r,s를 ethers.utils.joinSignature() 기능을 통해 합치면 된다.</p><p>이와 같은 방법으로 ethers를 통해 isValidSignature()를 통해 검증할 수 있는 메시지(hash)와 서명 값(signature)을 만들수 있다.</p><h4><strong>🔍 STEP 3 : REMIX 실습</strong></h4><p>EIP-1271를 Remix에 배포하여 실습을 진행해 보자.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/1*sDQDsCAmMx3FM_05JvHGPw.png" /></figure><p>현재 스마트컨트랙트 지갑의 Owner은 위와 같이0xf39…2266 이다. 하지만, 실제로 0xf39…2266 지갑의 소유권을 가진 사람은 누구인지 알 수 없다. 또한, 소유권을 증명하기 위해 당사자의 개인키를 요구할 수도 없다. 때문에, 우리는 스마트컨트랙트 지갑에 EIP-1271 표준이 정의되어 있다면 주인에게 아무 메시지나 서명해서 개인키 대신, 서명값을 요구할 수 있다. 그리고 <strong>isValidSignature()를 통해 서명값을 검증하여 당사자가 소유권을 가지고 있는지 확인할 수 있다.</strong></p><p>위 사진처럼, 소유권이 검증되면 magicValue라는 값이 리턴된다. 이를 통해 우리는 개인키 없이 스마트컨트랙트 지갑의 소유권을 증명할 수 있다.</p><h4>마무리</h4><p>지금까지 ERC-1271에 대해 알아봤다. 지갑의 소유권을 증명하는 과정은 굉장히 중요하다. 이를 통해, <strong>지갑에 보유 중인 디지털 자산이 정말 본인 것이 맞는지</strong>, <strong>지갑과 자산을 우리 Dapp 서비스에서 이용할 수 있는 사용자인지</strong> 확인할 수 있다. 이때 스마트컨트렉트 지갑의 소유권을 확인하는 방법은 ERC-1271가 등장하기 전까지 없었다.</p><p>현재 WEB3는 불편한 지갑 메커니즘을 다양한 방법으로 개선하기 위해 노력 중이다. 불편한 지갑을 개선시키는 Dapp 서비스는 WEB2 유저의 유입을 이끌 수 있기 때문이다. 스마트컨트렉트 지갑은 현재 활발하게 연구 중인 지갑 콘텐츠이며, 대부분의 관련 표준에 ERC-1271가 포함되고 있다.</p><p>때문에 이 글을 통해 ERC-1271가 어떻게 구현되었는지, 어떻게 활용되는지 이해하고 다른 지갑 표준을 접하면 더욱 빠르게 이해할 수 있을 것이다.</p><h3>💡 Reference</h3><ul><li><a href="https://www.dynamic.xyz/blog/eip-1271">EIP-1271: Signature Verification for Smart Contract Wallets</a></li><li><a href="https://eips.ethereum.org/EIPS/eip-1271">https://eips.ethereum.org/EIPS/eip-1271</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c77eddb46a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deep Dive into 미니멀 프록시(Minimal Proxy) : ERC-1167]]></title>
            <link>https://medium.com/@choi_eth/deep-dive-into-%EB%AF%B8%EB%8B%88%EB%A9%80-%ED%94%84%EB%A1%9D%EC%8B%9C-minimal-proxy-erc-1167-403fd1eb571b?source=rss-4858a4819f54------2</link>
            <guid isPermaLink="false">https://medium.com/p/403fd1eb571b</guid>
            <category><![CDATA[erc-1167]]></category>
            <category><![CDATA[minimal-proxy]]></category>
            <category><![CDATA[erc]]></category>
            <dc:creator><![CDATA[choi_eth]]></dc:creator>
            <pubDate>Thu, 27 Jul 2023 12:25:06 GMT</pubDate>
            <atom:updated>2024-03-22T16:17:15.877Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deep Dive Into ERC-1167 : 미니멀 프록시(Minimal Proxy)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZaXg4dmjiMhobLIbPkT9Mw.png" /></figure><h4>Author</h4><ul><li>최원혁(<a href="https://medium.com/u/4858a4819f54?source=post_page-----e371fe8a1d73--------------------------------">Choi WonHyeok</a>)</li></ul><p>스마트 컨트랙트를 개발하다 보면, 동일한 코드의 컨트랙트를 다수 배포해야 하는 경우가 있다. 필자는 DAO의 기능이 구현된 컨트랙트를 사용자 친화적인 UI를 통해 쉽게 배포할 수 있는 DAO Tooling 서비스를 개발한 적이 있다. 이때, DAO를 원하는 조직 또는 구성원이 서비스를 이용할 때마다 똑같은 코드의 컨트랙트를 계속 배포했다.<br>Minimal Proxy Contract는 위와 같이 완전히 동일한 로직을 갖는 컨트랙트를 여러 번 배포해야 하는 경우, 배포 비용을 최적화하기 위해 등장한 표준이다.</p><h3>What is Minimal Proxy?</h3><p>Minimal Proxy는 컨트랙트 배포의 최적화를 위해 등장했다. 때문에 “Minimal Proxy” 말 그대로 <strong>“최소한의 기능만 구현된 프락시 컨트랙트”</strong>를 의미한다. 여기서 말하는 <strong>“최소한의 기능”</strong>은 <strong>“이미 체인 어딘가에 배포된 컨트랙트를 프록시 패턴을 통해 호출하는 기능”</strong>을 말한다.</p><h3>프록시 패턴(Proxy Pattern)</h3><p>프록시란 컴퓨터 프로그래밍에서 메인 서버와 이어주는 중간다리 역할을 의미한다. 이러한 IT 용어에서 파생된 프록시 패턴(Proxy Pattern)은 Solidity에서 활용하는 코딩 방법론 중 하나이며, 프록시 패턴이 적용된 컨트랙트를 프록시 컨트랙트(Proxy Contract)라고 한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*Fk-4iEjar_OB8uiN6cpT3w.png" /><figcaption>출처 Openzeppelin Blog(<a href="https://blog.openzeppelin.com/proxy-patterns">링크</a>)</figcaption></figure><ul><li>Logic Contract : 실제 로직이 구현된 컨트렉트</li><li>Proxy Contract : Logic Contract의 코드를 실행하고 Storage의 역할을 하는 컨트렉트</li></ul><p>그림처럼 사용자가 프록시 컨트랙트로 어떠한 함수를 호출하면, 프록시 컨트랙트는 로직 컨트랙트로 호출을 넘겨, <strong>실제 로직이 구현된 로직 컨트랙트의 함수를 호출한다</strong>. 이때, 로직 컨트랙트는 함수만 호출하고, 컨트랙트에 저장해야 하는 데이터는 프록시 컨트랙트에 저장된다.</p><p>이러한 프록시 컨트랙트가 가능한 이유는 바로 Delegate Call 덕분이다. Solidity는 스마트 컨트랙트 내부에서 다른 컨트랙트를 호출할 때, call과 delegatecall 이 두 가지 기능 사용한다. call은 우리가 일반적으로 컨트랙트 함수를 호출할 때 사용하는 기능이지만, delegatecall은 특별한 기능을 갖고 있다.</p><h4>Delegate call</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/1*F84mxgLVXgVgghkNzM96rA.png" /><figcaption>출처 EIP-1822(<a href="https://eips.ethereum.org/EIPS/eip-1822">링크</a>)</figcaption></figure><p>delegate call를 사용하게 되면 다른 컨트랙트의 코드를 사용하지만, 실행환경(Context)은 기존의 delegate call을 실행한 프록시 컨트랙트에서 수행된다. 즉, 프록시 컨트랙트가 로직 컨트랙트를 호출할 때, `delegatecall`을 이용하게 되면 로직 컨트랙트의 코드를 사용하지만, Storage(테이저 저장 공간)는 프록시 컨트랙트를 사용하게 된다.</p><p>`delegatecall`을 활용한 프록시 패턴은 실행하는 위치가 그대로 유지되는 것이 핵심이며, Minimal Proxy의 최소한의 기능은 delegatecall을 활용한 프록시 패턴으로 구현되었다.</p><h3>Minimal Proxy Factory</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EmlOuIrk2P-zaGwlnjYDzg.png" /></figure><p>위 사진은 실제 서비스에서 사용되는 <strong>Minimal Proxy의 아키텍처</strong>이다. Minimal Proxy Factory는 factory pattern으로 구현되었으며, Minimal Proxy Contract를 배포하는 기능을 가진 컨트랙트이다.</p><p>위와 같은 아키텍처를 사용하는 경우, Factory Contract와 Logic Contract를 배포한다. 그리고 필요할 때마다 Factory에서 Minimal Proxy Contract를 복제하고, 프록시 패턴을 통해 Logic Contract에 구현된 함수를 사용한다.</p><p>‘복제’의 의미로 OpenZeppelin에서는 Minimal Proxy Factory를 <a href="https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Clones.sol">Clone.sol</a>로 정의하여 구현했다.</p><h4>Factory Pattern</h4><p>스마트 컨트렉트를 배포하기 위해 트랜잭션을 작성할 때, 트랜잭션 메시지의 필드 to에 Zero address를, data에 컨트랙트 코드를 컴파일 시킨 바이트 코드를 넣어서 보낸다. 그러면 EVM은 해당 트랜잭션의 바이트 코드를 통해 컨트랙트 배포한다.</p><p>하지만, <strong>Factory Pattern</strong>을 활용하면 Solidity를 통해 컨트랙트 내부에서도 컨트랙트를 배포할 수 있는 기능을 만들 수 있다.</p><pre>// SPDX-License-Identifier: MIT<br>pragma solidity ^0.8.17;<br><br>contract Car {<br>    address public owner;<br><br><br>    constructor(address _owner) payable {<br>        owner = _owner;<br>    }<br>}<br><br>contract CarFactory {<br>    Car[] public cars;<br><br>    function create(address _owner) public {<br>        Car car = new Car(_owner);<br>        cars.push(car);<br>    }<br>}</pre><p><strong>Factory Pattern</strong>는 다양한 방법으로 구현할 수 있지만, 가장 간단하고 쉽게 이해할 수 있는 방법은 Solidity new를 사용하는 것이다. 예시 처럼, CarFactory의 create() 함수 안에 new 연산자를 사용하면 Car 컨트랙트를 바이트 코드로 컴파일하여 배포할 수 있다. 이처럼 스마트 컨트랙트 내에서 다른 컨트랙트 배포하는 로직을 <strong>Factory Pattern</strong>이라고 한다.</p><p>Minimal Proxy Factory에는 더욱 최적화된 로직을 구현하기 위해 inline-assembly의 create 또는 create2를 사용한다. 해당 내용은 여기서 다루진 않지만, OpenZeppelin에 만든 <a href="https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Clones.sol">Clone.sol</a>를 참고하자.</p><h3>Minimal Proxy : Simple Code</h3><p>지금까지 Proxy Pattern과 Factory Pattern에 대해 알아봤다. 지금부터는 Minimal Proxy의 기능에 대해 알아보자.</p><pre>// SPDX-License-Identifier: MIT<br>pragma solidity ^0.8.17;<br><br>contract MinimalProxy {<br> address constant logicContract = &quot;0xbebebebebebebebebebebebebebebebebebebebe&quot;;<br><br> function delegate() external returns (bytes memory) {<br>  (bool success, bytes memory data) = logicContract.delegatecall(msg.data);<br>  require(success);<br><br>  return data;<br> }<br>}</pre><p>Minimal Proxy를 이해하기 쉽게 Solidity 코드로 구현하면 위와 같다. 위에서 언급한 대로 최소한의 기능만 구현하기 위해, delegate() 함수 안에 delegatecall을 활용한 프록시 패턴 딱 하나만 구현되어 있다. 모든 실행을 고정된 로직 컨트랙트로 delegatecall을 하고, 그 결과를 반환하는 것이 전부이다.</p><p>하지만 Minimal Proxy는 극단적으로 코드를 최적화하기 위해 동일한 기능을 수행하는 EVM 바이트 코드로 구현되어있다. ERC-1167에서 정의한 실제 Minimal Proxy 코드는 아래와 같다.</p><blockquote>3d602d80600a3d3981f3363d3d373d3d3d363d73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3</blockquote><blockquote>📌 Solidity로 구현된 예시 코드를 컴파일한다고 해서 위와 같은 바이트코드로 변환되지 않는다. 예시 코드는 단지 바이트코드로 되어있는 코드를 이해하기 쉽게 구현한 예시일 뿐이다.</blockquote><p>Solidity는 사람이 보고 이해할 수 있는 high-level 언어지만, 코드를 실행하는 EVM은 Solidity를 읽지 못한다. 때문에, 먼저 Solidity 코드를 컴파일하여 바이트 코드로 변환한 후, EVM 통해 코드를 실행(Runtime) 시킨다. 이처럼 바이트 코드는 프로그램을 위해 탄생한 low-level 언어이기에, 사람은 봐도 쉽게 이해할 수 없다.</p><p>하지만 바이트 코드는 이더리움에서 정의한 Opcode에 의해 동작하며, 각각의 Opcode는<a href="https://ethervm.io/"> ethervm.io</a>에 설명과 함께 잘 정의되어 있다. 이를 보고 바이트코드를 번역하면서 차근차근 하나씩 깊게 이해해 보자.</p><h3>Deep Dive into Minimal Proxy</h3><p>지금부터 나오는 내용은 EVM의 Opcode 동작 방식과 스마트 컨트랙트의 Stack &amp; Memory에 대한 지식이 부족하면 이해하기 어렵다. 하지만 Opcode 부분은 넘어가고, 각각의 동작 과정에 적어둔 <strong>설명</strong>만 봐도 Minimal Proxy에 대해 충분히 이해할 수 있으니 참고하여 보면 좋을 것 같다.</p><h4>Creation Code vs Runtime Code</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9fE26TWdpRKkqDdd_1FSqA.png" /></figure><p>ERC-1167에서 정의한 Minimal Proxy 컨트랙트 코드는 두가지 역할로 나누어 진다.</p><ul><li>Creation Code : 컨트랙트 배포를 수행하는 코드</li><li>Runtime Code : 컨트랙트 배포 후 사용되는 런타임 바이트코드</li></ul><p><strong>🔍 Creation Code</strong><br>Creation Code는 Init Code라고도 불리며, Runtime 바이트코드를 메모리에 복사하여 리턴한다. Solidity의 생성자 함수(constructor)도 여기서 호출된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*De6YQVuXUtyPN9aKsAMf0g.png" /><figcaption>출처 ethereum docs (<a href="https://ethereum.org/ko/developers/docs/accounts/">링크</a>)</figcaption></figure><p>스마트컨트랙트 주소에는 위 이미지와 같이 4가지 필드가 존재한다. 리턴된 Runtime 바이트코드는 컨트랙트의 code hash라는 공간에 저장되는데, 실제 스마트 컨트렉트를 동작하는 기능이 저장되어 있다.</p><p><strong>🔍 Runtime Code</strong><br>Runtime Code는 실제 스마트 컨트랙트를 동작하는 기능이 바이트코드 형태로 변환된 것이다. Solidity로 구현된 함수가 바이트 코드 형태로 저장되어 있고, 사용자가 컨트랙트로 트랜잭션을 보내면 code hash에 있는 Runtime 바이트 코드를 통해 동작하게 된다.</p><pre>contract Caller {<br>    function call(address implement) public view returns(bytes memory result) {<br>        result = implement.code;<br>    }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/283/1*irAA2YpKijNY-5Bc2QfG4Q.png" /></figure><p>실제 Minimal Proxy Contract의 code hash를 조회하면 Logic Contract 주소(bebebebebebebebebebebebebebebebebebebebe)를 제외하고 ERC-1167에서 정의한 바이트 코드와 동일하다.</p><h3>Deep Dive into Runtime Code</h3><p>지금부터는 동작의 순서대로 바이트코드를 해석할 것이다. EIP-1167의 Opcode는 EVM의 Stack과 Memory만 활용한다. 동작 순서대로 Stack과 Memory에 저장되는 구조를 그리면서 보면 쉽게 이해할 수 있다.</p><p>만약 바이트 코드가 EVM의 Stack과 Memory에 그려지지 않는다면, Openzeppelin에서 작성한 글을 같이 보면서 읽으면 좋을 것 같다. 여기선 나름 동작의 순서대로 Stack과 Memory의 상태를 테이블로 잘 표현했다.</p><p><a href="https://blog.openzeppelin.com/deep-dive-into-the-minimal-proxy-contract">Deep dive into the Minimal Proxy contract - OpenZeppelin blog</a></p><p>다시 말하지만 EVM의 Opcode 동작 방식과 스마트 컨트랙트의 Stack/Memory를 잘 모른다면 설명 부분만 보고 각 순서에서 어떤 동작을 하는지만 이해하자.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JxaL670hj1Jku6Rkb9FOZw.png" /></figure><p>Creation Code는 잠시 두고, 먼저 사용자가 Minimal Proxy 컨트랙트로 트랜잭션을 보내면 동작하는 Runtime Code에 대해 알아보자.</p><h4># STEP 1 . Get the call data : 363d3d37</h4><p>설명 : 사용자가 Minimal Proxy 컨트랙트로 트랜잭션을 보냈을 때, 가장 처음 동작하는 부분이다. 여기서 call data란 호출(call)에 필요한 데이터(data)로 사용자가 컨트랙트 함수를 실행하기 위해 트랜잭션에 포함시킨 데이터를 의미한다. solidity에서 msg.data로 calldata를 읽을 수 있지만, Minimal Proxy에서는 역시 최적화를 위해 바이트코드로 구현했다. 이 과정을 통해 사용자가 전송한 call data를 메모리에 저장한다.</p><ol><li>CALLDATASIZE [36] : msg.data(call data)의 length(길이)를 bytes형태로 반환한다.</li><li>RETURNDATASIZE [3d] : 가장 마지막 리턴 데이터 길이를 bytes형태로 반환한다.<br><em>📌 리턴된 데이터가 없는 경우 0을 반환한다.</em></li><li>RETURNDATASIZE [3d] : 2. 와 동일</li><li>CALLDATACOPY(t, f, s)[37] : msg.data 의 f번째 위치에서 s개의 바이트를 읽어 메모리의 t번째 위치에 저장한다.</li></ol><h4># STEP 2. Delegating the call : 3d3d3d363d73bebebebebebebebebebebebebebebebebebebebe5af4</h4><p>설명 : 이번 과정에서는 call data를 Logic Contract로 delegate call 동작하는 부분이다.</p><ol><li>RETURNDATASIZE [3d] : 가장 마지막 리턴 데이터 길이를 bytes형태로 반환한다.</li><li>RETURNDATASIZE [3d] : 1.와 동일</li><li>RETURNDATASIZE [3d] : 1. 와 동일</li><li>CALLDATASIZE [36] : msg.data(call data)의 length(길이)를 bytes형태로 반환한다.</li><li>RETURNDATASIZE [3d] : 1.와 동일</li><li>PUSH20 bebe… [73 bebe…bebe] : 스택 맨 위(top)에 Logic Contract 주소(bebe…bebe) 20바이트를 추가한다.</li><li>GAS[5a] : 남아있는 가스를 반환한다.</li><li>DELEGATECALL(g, a, in, insize, out, outsize) [f4] : context(msg.sender,msg.value,this) 변화 없이 가스 g를 소모하여 다른 컨트랙트 a의 함수를 호출한다. **in**은 msg.data값의 메모리상의 위치, **insize**는 해당 인풋의 길이를 말하며, <strong>메모리의 </strong><strong>in ~ in + insize — 1 위치의 값(msg.data)를</strong> 사용한다. 만약 위 함수가 값을 반환(return)한다면 메모리의 out ~ out + outsize — 1 에 해당 반환값을 저장한다.<br><em>📌 DELEGATECALL은 동작 후, SUCCESS라는 이름의 값을 스택의 top에 추가한다. 여기서 SUCCESS가 0이면 실패, 0이 아니면 성공하게된 것이다.</em></li></ol><h4># STEP 3. Get the result of an external call : 3d82803e</h4><p>설명 : 이번 과정에서는 <strong><em># STEP 2</em></strong> 과정을 통해 호출한 delegate call의 결과값을 얻어 메모리에 저장한다.</p><ol><li>RETURNDATASIZE [3d] : 가장 마지막 리턴 데이터 길이를 bytes형태로 반환한다.</li><li>DUP3 [82] : 스택의 3번째 값을 복사해 스택의 top에 추가한다.</li><li>DUP1 [80] : 스택의 1번째 값을 복사해 스택의 top에 추가한다.</li><li>RETURNDATACOPY(t, f, s) [3e] : 가장 마지막 리턴 값의 f번째 위치에서 s개의 바이트를 읽어 메모리의 t번째 위치에 저장한다.<br><em>📌 여기서 가장 마지막 리턴 값은 delegate call의 결과값이다.</em></li></ol><h4># STEP 4. Final stage: return or revert : 903d91602b57fd5bf3</h4><p>설명 : 이번 과정에서는 메모리에 저장된 delegate call의 결과값을 보고 반환(return)할것인지, 리버트(revert)할 것인지 결정을 하게 된다.</p><p>우리는 2–8 DELEGATECALL을 통해 스택에 SUCCESS라는 변수를 남겼다.</p><p><strong>• if SUCCESS = 0 </strong>: <br>DELEGATECALL은 실패한게 되고, 사용자의 트랜잭션을 revert해야한다.<br><strong>• if SUCCESS != 0</strong> : <br>DELEGATECALL은 성공한게 되고, 결과값을 return해야한다.</p><ol><li>SWAP1 [90] : 스택의 1번째 값과 스택의 top의 값을 교환 한다.</li><li>RETURNDATASIZE [3d] : 가장 마지막 리턴 데이터 길이를 bytes형태로 반환한다.<br><em>📌 여기서 가장 마지막 리턴 값은 delegate call의 결과값이다.</em></li><li>SWAP2 [91] : 스택의 2번째 값과 스택의 top의 값을 교환 한다.</li><li>PUSH1 2b [60 2b] : 스택 맨 위(top)에 2b(43) 1바이트를 추가한다.</li><li>JUMPI (destination, condition) [57] : 조건 condition 에 따라 다음 Opcode를 실행할지, destination 에 해당하는 다음 Opcode로 점프하여 실행할지 결정한다.</li><li>REVERT(offset,length) [fd] : 메모리의 offset ~ offset + length 위치에 저장된 데이터와 함께 Revert를 반환한다.</li><li>JUMPDEST [5b] : JUMPI의 condition이 TRUE시 동작 순서를 해당 위치로 점프한다.<br><em>📌 단, JUMPI의 </em><em>destination이 JUMPDEST의 Opcode 포지션 값(2b)일 경우이다.</em></li><li>RETURN(offset,length) [f3] : 메모리의 offset ~ offset + length 위치에 저장된 데이터를 반환하고 runtime(코드 실행)을 종료한다.</li></ol><h3>Deep Dive into Creation Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1009/1*HCqHETZcvwJ8M6aO249SIA.png" /></figure><p>위에서 말한거 처럼 Creation Code는 스마트컨트랙트 배포를 동작하기 위한 바이트 코드이다. Runtime Code를 메모리에 저장하고, 해당 컨트랙트의 code hush에 저장한다. 마찬가지로 동작 순서대로 Stack과 Memory에 저장되는 구조를 그리면서 이해해보자.</p><h4># Creation Code : 3d602d80600a3d3981f3</h4><ol><li>RETURNDATASIZE [3d] : 가장 마지막 리턴 데이터 길이를 bytes형태로 반환한다.</li><li>PUSH1 2d [60 2d] : 스택 맨 위(top)에 2d(45) 1바이트를 추가한다.<br><em>📌 지금까지 메모리에 저장된 Runtime Code의 바이트 수는 45이다.</em></li><li>DUP1 [80] : 스택의 1번째 값을 복사해 스택의 top에 추가한다.</li><li>PUSH1 0a [60 0a] : 스택 맨 위(top)에 0a(10) 1바이트를 추가한다.</li><li>RETURNDATASIZE[3d] : 1.와 동일</li><li>CODECOPY(destOffset, offset, length) [39] : 현재 환경에서 실행 중인 컨트랙트의 바이트코드의 offset ~ offset+length만큼을 메모리의 destOffset 위치에 복사한다.</li><li>DUP2 [81] : 스택의 2번째 값을 복사해 스택의 top에 추가한다.</li><li>RETURN(offset,length) [f3] : 메모리의 offset ~ offset + length 위치에 저장된 데이터를 반환하고 runtime(코드 실행)을 종료한다.</li></ol><h3>마무리</h3><p>지금까지 ERC-1167에서 정의한 Minimal Proxy에 대해서 알아봤다. 간단한 동작만 이해한다면 어렵지 않게 이해할 수 있지만, 바이트코드라는 low-level 언어 측면으로 이해하려면 알아야 하는 지식이 굉장히 많다. 그래도 차근차근 순서대로 동작하는 Opcode를 찾아 보면서 이해할 수 있었다. 그 과정을 글로 표현하는 게 쉽지는 않았기에, 내가 이해한 모든 지식이 독자분들에게 제대로 전달되었을지 걱정된다. 궁금한 점에 대해 댓글을 달아주면 성심성의껏 답변을 드리겠다는 약속을 하며 이만 글을 마치겠다.</p><h3>Reference :</h3><ul><li><a href="https://eips.ethereum.org/EIPS/eip-1167">ERC-1167: Minimal Proxy Contract</a></li><li><a href="https://medium.com/onther-tech/solidity-assembly-abi-encoding-db8f79d1c1a1">Solidity Assembly &amp; ABI Encoding</a></li><li><a href="https://blog.openzeppelin.com/deep-dive-into-the-minimal-proxy-contract">Deep dive into the Minimal Proxy contract - OpenZeppelin blog</a></li><li><a href="https://ethervm.io/#B2">Ethereum Virtual Machine Opcodes</a></li><li><a href="https://medium.com/@aiden.p/%EC%97%85%EA%B7%B8%EB%A0%88%EC%9D%B4%EB%8D%94%EB%B8%94-%EC%BB%A8%ED%8A%B8%EB%9E%99%ED%8A%B8-%EC%94%A8-%EB%A6%AC%EC%A6%88-part-4-%EB%AF%B8%EB%8B%88%EB%A9%80-%ED%94%84%EB%A1%9D%EC%8B%9C-%EC%BB%A8%ED%8A%B8%EB%9E%99%ED%8A%B8-%ED%95%B4%EC%B2%B4-%EB%B6%84%EC%84%9D%ED%95%98%EA%B8%B0-7cf518133ba0">[업그레이더블 컨트랙트 씨-리즈] Part 4 — 미니멀 프록시 컨트랙트 해체 분석하기</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=403fd1eb571b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>