<?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 WEU FOUNDATION on Medium]]></title>
        <description><![CDATA[Stories by WEU FOUNDATION on Medium]]></description>
        <link>https://medium.com/@weufoundation?source=rss-b9cf26a7e25b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ST2cnYpY34kMMN4HLPUO3A.jpeg</url>
            <title>Stories by WEU FOUNDATION on Medium</title>
            <link>https://medium.com/@weufoundation?source=rss-b9cf26a7e25b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:13:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@weufoundation/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[FOUNDATIONS OF DATA AVAILABILITY SAMPLING]]></title>
            <link>https://weufoundation.medium.com/foundations-of-data-availability-sampling-1a8033d8c9fc?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a8033d8c9fc</guid>
            <category><![CDATA[data-availability]]></category>
            <category><![CDATA[ethereum-blockchain]]></category>
            <category><![CDATA[erasure-coding]]></category>
            <category><![CDATA[celestia]]></category>
            <category><![CDATA[blob-storage]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Wed, 31 Jan 2024 01:43:46 GMT</pubDate>
            <atom:updated>2024-01-31T01:58:11.446Z</atom:updated>
            <content:encoded><![CDATA[<p>Written by — <a href="https://www.linkedin.com/in/fardeen-khan-093938212/">(3) Fardeen Khan | LinkedIn</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYr3D3LRPZyCF2GexdZtYw.jpeg" /></figure><p>In this series of blogs, I will explore the following topics related to data availability and blockchain:</p><ul><li>The foundation: What is data availability, why is it essential for blockchain security and trustlessness, and what are the challenges and trade-offs of achieving it?</li><li>The why: What are the business drivers and use cases for data availability in blockchain, and how does it support innovation and adoption in various sectors and industries?</li><li>The what: What are the key components and features of data availability in blockchain, and what are the best practices and standards to follow?</li><li>The how: How can you implement data availability solutions in your blockchain environment, and what are the tools and technologies that can help you?</li><li>The solutions: What are some &amp; new solutions of the data availability available in the blockchain market, and how do they compare and contrast?</li></ul><p>By the end of this series, you will have a comprehensive understanding of data availability and how it can help you optimize your blockchain performance and functionality.</p><p>TODAY , IN THIS BLOG WE ARE GOING TO DICUSS THE FOUNDATIONS OF DATA AVAILABILITY…..</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_I6IrFC6eqbumJ6BisD7Q.png" /></figure><p>Data availability sampling (DAS) is a technique that allows nodes to verify the availability of data without downloading the entire data. The motivation for DAS is to reduce the bandwidth and storage requirements for nodes, especially for large-scale or high-throughput systems, such as blockchains or rollups.</p><p>The setting for DAS is as follows:</p><ul><li>There is a block producer who generates a block of data and claims to have made it available to the public.</li><li>There is a verifier who wants to check the availability claim, but does not want to download the entire block of data.</li><li>There is a bulletin board where the block producer can post some information about the block of data, such as a hash or a Merkle root.</li><li>There is a random oracle that can generate random challenges for the verifier to query the block producer.</li><li>There is a communication channel between the verifier and the block producer, where the verifier can request specific pieces of data from the block producer, and the block producer can respond with the requested data or a proof of unavailability.</li></ul><p>The basic idea of DAS is that the verifier can sample a small fraction of the block of data, using the random oracle and the bulletin board as guides, and check if the sampled data matches the information posted on the bulletin board. If the sampled data is consistent, the verifier can be confident that the block of data is available with high probability. If the sampled data is inconsistent or missing, the verifier can reject the availability claim and penalize the block producer.</p><p>HERE WE WILL FRAME OUT FURTHER IN THE BLOG …. WHAT DO WE MEAN BY AVAILABILITY AND EFFICIENT AVAILABILITY!!!</p><h3>GENERIC DAS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kh2aY3U-J_-OP0cij644Kw.png" /></figure><p>A Merkle tree is a data structure that creates a root of the data inside the block by hashing together pairs of transactions until there is only one hash left. This hash is called the Merkle root or the root hash, and it is considered as the block header, which is downloaded by light clients.</p><p>A light client is a node that does not store the entire blockchain, but only the block headers. It can verify the existence and validity of a transaction by requesting a proof from a full node, which consists of the transaction itself and the hashes along the path from the transaction to the Merkle root.</p><p>The Merkle tree allows the light client to verify the proof efficiently and securely, without needing to download the entire block of data. The light client can check if the transaction hash matches the leaf node, and then hash it with the adjacent node to get the parent node. This process is repeated until the light client reaches the Merkle root, which can be compared with the block header. If the Merkle root matches the block header, the light client can be confident that the transaction is included in the block.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N2FKvB3Q1Z5PTnKbG5VLgw.png" /></figure><p>The clients can check the data availability by using a technique called data availability sampling (DAS). DAS allows clients to verify the availability of data without downloading the entire data. The clients can sample a small fraction of the data, using a random oracle and a bulletin board as guides, and check if the sampled data matches the information posted on the bulletin board. If the sampled data is consistent, the clients can be confident that the data is available with high probability. If the sampled data is inconsistent or missing, the clients can reject the availability claim and penalize the proposer.</p><ul><li>DAS is especially useful for scaling blockchains, as it enables the separation of computation from consensus, and allows for off-chain solutions that can increase transaction throughput and reduce costs2.</li><li>DAS relies on the assumption that the proposer publishes the data on the network and posts the hash or the Merkle root of the data on the bulletin board. The clients can request specific pieces of data from the proposer or other nodes, and verify them against the hash or the Merkle root.</li></ul><h3>DAS USING ERASURE CODING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J8bvr5iVPFnYIKiZX2TBQQ.png" /></figure><p>Erasure coding is a method that splits the data into smaller chunks and adds some redundancy, so that the original data can be recovered from a subset of the chunks. Reed-Solomon code is a type of erasure code that uses polynomials to generate the chunks. KZG commitment scheme is a cryptographic primitive that allows a prover to commit to a polynomial and later reveal any evaluation of the polynomial in a succinct and verifiable way.</p><p>The relation between network nodes who download these redundant data chunks and clients who sample them is as follows:</p><ul><li>The proposer who produces the data block uses Reed-Solomon code to encode the data into N chunks, where only M &lt; N chunks are needed to reconstruct the data. The proposer also uses KZG commitment scheme to commit to the polynomial that generates the chunks, and publishes the commitment on a bulletin board along with the data availability root (DAR), which is a Merkle root of the chunks.</li><li>The network nodes who download the data block store the chunks that they receive, and use the DAR to verify that the chunks are consistent. They also use the KZG commitment to verify that the chunks are generated by the same polynomial. The network nodes act as data providers who can respond to data requests from clients.</li><li>The clients who want to check the data availability use a random oracle to sample a small fraction of the chunks, and request them from the network nodes. They use the DAR to verify that the chunks are consistent, and use the KZG commitment to verify that the chunks are generated by the same polynomial. If the sampled chunks match the information on the bulletin board, the clients can be confident that the data is available with high probability. If the sampled chunks are inconsistent or missing, the clients can reject the availability claim and penalize the proposer.</li></ul><p>The advantage of using KZG commitments over hashes of the data is that KZG commitments allow for more efficient and secure verification of the chunks, as they only require one group element per polynomial, and they are hiding and binding, meaning that the proposer cannot change the polynomial after committing to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UKqTXg4uszeunwVXVfU7qw.png" /></figure><p>HERE WE ARE GOING TO DISCUSS MORE THE FORMAL DEFINITION , CONSTRUCTION FRAMEWORKS AND DIFFERENT KIND OF CONSTRUCTIONS AVAILABLE OUT THERE…..</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kVWoX60Eb8FUCTP4pBj2Lw.png" /></figure><p>Data availability sampling (DAS) technique, which allows clients to verify the availability of data without downloading the entire data, by using erasure coding and polynomial commitments.</p><p>Verifier 1 and verifier 2 are two roles that are responsible for sampling and verifying the data chunks in DAS. They receive inputs i and πi from the network, where i is the index of the chunk and πi is the evaluation of the polynomial at i. They process these inputs through an operation called tran, which stands for transcript, and output a binary decision represented as b ∈ {0,1}. This decision indicates whether the data chunk is available and consistent with the information on the bulletin board, where the proposer has published the commitment and the data availability root (DAR) of the data block.</p><p>Verifier 1 and verifier 2 operate in parallel and seem to perform the same function but for different clients. They can also communicate with each other and exchange their transcripts, which are the records of their sampling and verification process. The purpose of having two verifiers is to increase the security and reliability of DAS, as they can cross-check their results and detect any malicious or faulty behavior by the proposer or the network nodes.</p><p>An extractor is responsible for recovering the original data from the data chunks in data availability. An extractor can use an erasure code decoder to reconstruct the data from a subset of the chunks, as long as the minimum number of chunks is available. An extractor can also use a polynomial interpolator to recover the polynomial that generates the chunks, and evaluate it at any point to obtain the corresponding data. An extractor can be a client who wants to access the data, or a verifier who wants to check the data consistency. Data extraction is the final step in data availability sampling (DAS), which is a technique that allows clients to verify the availability of data without downloading the entire data, by using erasure coding and polynomial commitments.</p><h3>PROPERTIES NEEDED IN DAS SETTINGS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_jwINa8pdFMmaMvped5Mg.png" /></figure><p>The property of completeness in data availability sampling (DAS) is the guarantee that the data is available and consistent with the information posted by the proposer on the bulletin board, where the proposer has published the commitment and the data availability root (DAR) of the data block. Completeness means that the clients can sample and verify a small fraction of the data chunks, and then extract the original data from the chunks, using erasure coding and polynomial commitments. Completeness is one of the two main properties of DAS, along with soundness, which is the guarantee that the data is unavailable or inconsistent if the clients reject the availability claim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NPVdhJxRV2XEaVugYXgGrQ.png" /></figure><p>The property of soundness in data availability sampling (DAS) is the guarantee that the data is unavailable or inconsistent if the clients reject the availability claim. Soundness means that the clients can detect and penalize any malicious or faulty behavior by the proposer or the network nodes, who may try to make the data unavailable or corrupt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MOU7BNtMuqK2zVo3xe6tWg.png" /></figure><p>The notion of consistency in DAS is that if both extractions don’t output a specific data, they should then extract the same data. This property ensures that even in the presence of an adversarial node, the extracted data remains consistent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PFksTD-VjiMgiuQMivZPKQ.png" /></figure><h4>SOME OTHER PROPERTIES FOR DAS</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kiU5WBf4BgIMupX5gSWrSQ.png" /></figure><p><strong>Repairability</strong> function in DAS is a function that measures how easily a data block can be repaired or reconstructed from a subset of its chunks. Repairability function depends on the erasure code and the polynomial commitment used to encode and commit the data block, as well as the number and distribution of the available chunks. Repairability function is used to evaluate the performance and trade-offs of different DAS schemes, such as the sampling rate, the verification time, and the security level.</p><p><strong>Local accessibility</strong> in DAS is the ability of a client to access the data chunks that are stored on the network nodes that are close to the client, without relying on the network connectivity or the availability of other nodes. Local accessibility can improve the performance and reliability of DAS, as it reduces the latency and the bandwidth consumption of the data requests and responses. Local accessibility can also enhance the security and privacy of DAS, as it limits the exposure and the leakage of the data chunks to the network.</p><h3>CONSTRUCTION FRAMEWORK</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fhRvz-RpX5b-l0DrB8JIsg.png" /></figure><p>Construction frameworks for data availability sampling (DAS) are the methods and principles that guide the design and implementation of DAS schemes.</p><p>There are different construction frameworks for DAS, depending on the choice of erasure code, polynomial commitment, sampling strategy, and verification protocol. Some examples of construction frameworks are:</p><ul><li>The original DAS framework proposed by Buterin et al., which uses Reed-Solomon codes, Kate-Zaverucha-Goldberg (KZG) commitments, random sampling, and interactive verification.</li><li>The improved DAS framework proposed by Nikolaenko and Boneh, which uses Namespaced Merkle Trees (NMTs), KZG commitments, random sampling, and non-interactive verification.</li><li>The generalized DAS framework proposed by Al-Bassam et al., which uses any linear erasure code, any polynomial commitment, adaptive sampling, and interactive verification.</li></ul><p>Each construction framework has its own advantages and disadvantages, such as the sampling rate, the verification time, the security level, and the practical feasibility. The choice of the construction framework depends on the goals and requirements of the DAS application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HbPLVevuZ3EyciOgYf71hQ.png" /></figure><p>To map a message into a codeword by adding redundancy, DAS uses erasure coding, which is a method that splits the data into smaller chunks and adds some extra chunks, so that the original data can be recovered from a subset of the chunks.</p><p>The advantage of adding redundancy is that it increases the resilience and the repairability of the data, as it allows the data to be reconstructed even if some chunks are missing or corrupted. The disadvantage is that it increases the size and the complexity of the data, as it requires more storage and computation resources.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdH-ae_HlR_ByC3GJhJXOw.png" /></figure><p>Linear codes are a type of error-correcting codes that use linear algebra to encode and decode messages.</p><p>To check whether the matrix has the available data or not, DAS uses a generator matrix and a parity-check matrix. The generator matrix is a matrix that can generate all the codewords in the linear code by multiplying it with the message vector. The parity-check matrix is a matrix that can verify whether a vector is a codeword or not by multiplying it with the vector and checking if the result is zero.</p><p>DAS uses the generator matrix to encode the data into chunks, and the parity-check matrix to verify the consistency and validity of the chunks. DAS also uses polynomial commitments to commit to the generator matrix and the data availability root (DAR), which is a Merkle root of the chunks. DAS samples a small fraction of the chunks and requests them from the network nodes. DAS uses the parity-check matrix and the polynomial commitments to verify that the chunks are consistent and generated by the same generator matrix. If the sampled chunks match the information on the bulletin board, where the proposer has published the commitment and the DAR, DAS can be confident that the data is available with high probability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MmgtEVUVJw6Qooar1KBKGQ.png" /></figure><p>Erasure codes are a technique for storing data in a way that allows recovery from partial loss or corruption. They divide a message into n symbols and add some redundancy, so that the original message can be reconstructed from any k symbols, where k is less than or equal to n. The ratio k/n is called the code rate, and it measures the space efficiency of the erasure code. The ratio k’/k, where k’ is the minimum number of symbols needed for recovery, is called the reception efficiency, and it measures the recovery performance of the erasure code.</p><p>One example of an erasure code is the parity check, where n = k + 1 and one symbol is the sum of the other k symbols. Another example is the polynomial oversampling, where a polynomial function is used to generate n symbols from k symbols, and any k symbols can be used to recover the original message. There are also more complex erasure codes, such as MS-LRC and Xorbas, that use local and global parities to achieve different trade-offs between space efficiency, durability, and recovery performance.</p><h3>ERASURE CODE COMMITMENTS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K6I2MvQ5Fo3CUL8q3GCbnQ.png" /></figure><ul><li><strong>Code</strong>: A message x is encoded into n codewords c using a code function 𝒞. The code function maps from a space ℝᵏ to another space 𝓛ⁿ, where k is the number of original symbols and n is the number of encoded symbols. The code function should have the property that any k symbols can recover the original message x.</li><li><strong>Commit to Codewords</strong>: The sender computes a commitment com to the codewords c using a cryptographic hash function. The commitment com is a fixed-length value that hides the codewords c, but allows the sender to prove that they know them later.</li><li><strong>Open Positions</strong>: The receiver chooses some positions i in the set [n] and asks the sender to open them. The sender reveals the corresponding codewords cᵢ and tags τᵢ, where the tags are additional values that prove the correctness of the codewords. The receiver verifies that the commitment com, the positions i, the codewords cᵢ, and the tags τᵢ are consistent using a verification algorithm.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gbh1vtKvsmRbg7gDXXyN-Q.png" /></figure><p>Position binding and code binding are two security properties of erasure code commitments, which are a way of committing to a sequence of values using erasure codes.</p><ul><li><strong>Position binding</strong> means that an adversary cannot open a commitment to two different values at the same position. For example, if the sender commits to a sequence of four values (a, b, c, d), the receiver should not be able to obtain two valid openings for the same position, such as (1, a) and (1, e).</li><li><strong>Code binding</strong> means that an adversary cannot open a commitment to a value that is not consistent with the code function used to generate the codewords. For example, if the sender uses a polynomial function to encode two values (a, b) into four codewords (c1, c2, c3, c4), the receiver should not be able to obtain a valid opening for a value that does not lie on the polynomial, such as (3, f).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nrrtaXSX_jXHIZddgcNZoQ.png" /></figure><ul><li><strong>Index Sampler</strong>: The index sampler is a component that allows the receiver to query specific positions of the data and obtain the corresponding openings from the sender. The receiver chooses a subset of indices, denoted by ij, …, iq, and sends them to the sender. The sender responds with the openings for those indices, denoted by πif, …, πiq. The receiver verifies the openings using the verification algorithm, which checks that the commitment, the indices, the codewords, and the tags are consistent. If the verification succeeds, the receiver can recover the data values at those positions.</li><li><strong>Analysis</strong>: The commitment and the openings are analyzed for various properties, such as reception efficiency, quality of sampler, position-binding, and code-binding. These properties measure the performance and security of the erasure code commitment scheme. For example, reception efficiency is the ratio of the minimum number of openings needed for recovery to the number of original values, and it indicates the space efficiency of the scheme. Quality of sampler is the probability that a random sample of openings can recover the original data, and it indicates the sampling accuracy of the scheme. Position-binding and code-binding are security properties that prevent the sender from opening the commitment to different values at the same position or to values that are not consistent with the erasure code function, respectively. These properties ensure the integrity and confidentiality of the data. The analysis also leads to completeness and soundness, which are correctness properties that guarantee that the receiver can always recover the data if the sender is honest, and can always detect if the sender is cheating, respectively.</li></ul><h3><strong>CONSTRUCTION SCHEMES</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DSZThP-EuJ6H3rFdW42dXQ.png" /></figure><p>We already had a looked over reed-solomon and kzg while going through the early phase of the blog.</p><h4>ARBITRARY — — — VECTOR COMMITMENT+SNARK</h4><p>To construct DAS for arbitrary code, one possible approach is to use vector commitments and SNARKs (Succinct Non-interactive ARguments of Knowledge) as the commitment scheme. Vector commitments are a special case of functional commitments, where the function is the identity function. They allow the sender to commit to a vector of values, and later open the commitment to any value at any position. SNARKs are a type of proof system that allow the sender to prove that they know a witness for a statement, such as the evaluation of a circuit, in a succinct and non-interactive way.</p><p>The idea is to use vector commitments to commit to the codewords of the erasure code, and SNARKs to prove the correctness of the openings. The sender encodes the data using an erasure code, and commits to the codewords using a vector commitment scheme. The sender also generates a SNARK proof for each codeword, showing that it is consistent with the erasure code function and the commitment. The receiver queries some positions of the data, and the sender responds with the corresponding codewords and SNARK proofs. The receiver verifies the vector commitment openings and the SNARK proofs, and recovers the data values at those positions.</p><p>This approach can achieve DAS construction for arbitrary code, as long as the erasure code function and the vector commitment scheme can be expressed as circuits that can be verified by SNARKs.</p><p>However, Merkle trees alone cannot be used to implement DAS for arbitrary code, because they do not provide a way to prove the correctness of the openings. For that, we need a proof system that can verify the evaluation of a circuit that represents the erasure code function and the vector commitment scheme. SNARKs are one such proof system that can generate succinct and non-interactive proofs for arbitrary circuits. Therefore, we need both Merkle trees and SNARKs to construct DAS for arbitrary code.</p><h4>TENSOR CODE — — — ROW-WISE COMMITMENTS</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6NtAoYjU6ntSYUSUrfKgdA.png" /></figure><p>Tensor codes are a type of erasure codes, which are techniques for storing data in a way that allows recovery from partial loss or corruption. Erasure codes divide a message into n symbols and add some redundancy, so that the original message can be reconstructed from any k symbols, where k is less than or equal to n. Tensor codes are a special class of erasure codes that use tensor products to generate the codewords. Tensor codes have some advantages over other erasure codes, such as lower encoding and decoding complexity, higher reception efficiency, and better error correction capability.</p><p>Ethereum uses tensor codes for data availability sampling (DAS), which is a technique that allows the participants of a network to ensure the full availability of some data without any one participant downloading it entirely.</p><p>Ethereum uses row-wise commitment scheme in its data availability sampling protocol, which is part of its danksharding roadmap. Data availability sampling is a way for clients to verify that the data posted by a proposer in a peer-to-peer network is available and consistent, without downloading the entire data.</p><p>Some key points about the row-wise commitment scheme are:</p><ul><li>It is based on the tensor code, which is an Erasure code that extends the data along the rows and columns using a base code, such as the Reed-Solomon code.</li><li>It commits to each row of the tensor code using a polynomial commitment scheme, such as the KZG commitment scheme, and then checks the columns homomorphically using the parity check matrix of the base code.</li><li>It has the advantages of constant-size evaluation proofs, local reconstruction, and compatibility with zero-knowledge techniques.</li><li>It requires a trusted setup for the KZG commitment scheme, which can be done using a multi-party computation protocol.</li></ul><h4>INTERLEAVE CODE — — — HASH BASED</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MzPhTpYVuaD246PoJrQb-g.png" /></figure><p>Interleaved codes are a type of error correcting codes that can deal with burst errors, which are errors that occur in a sequence or as groups. Interleaved codes rearrange the order of the encoded bits so that the burst errors are distributed across multiple codewords, and then use random error correcting codes to correct them. Interleaved codes use erasure codes, hash functions, and interactive proofs to achieve this goal.</p><p>Hash-based construction in interleaved codes is a method of generating erasure codes that can correct burst errors, which are errors that occur in a sequence or as groups. Hash-based construction uses hash functions to map the original data into different codewords, and then interleaves the codewords to distribute the burst errors across multiple codewords. Hash-based construction can achieve high error correction capability and low decoding complexity, as well as security and privacy benefits.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SHhrlkQHel3rGvbS_ojktw.png" /></figure><p>Here is an in-depth explanation of each element:</p><ul><li><strong>x1,1 … xk,n</strong>: This is a matrix representing some form of encoded data or variables in coding theory. The matrix has k rows and n columns, and each entry is denoted by xi,j, where i is the row index and j is the column index. The matrix can be interpreted as a set of k codewords, each of length n, or as a set of n codewords, each of length k, depending on the orientation of the matrix.</li><li><strong>c1 … cn</strong>: This is a vector representing the commitment to the codewords. The vector has n entries, and each entry is denoted by ci, where i is the index of the codeword. The commitment is a fixed-length value that is computed using a cryptographic hash function. The commitment hides the codewords, but allows the sender to prove that they know them later.</li><li><strong>com = (h1,…,hn,W)</strong>: This is an equation defining the commitment vector. The commitment vector com is composed of two parts: a vector of hash values (h1,…,hn) and a vector of witnesses W. The hash values are obtained by applying a hash function to each codeword, and the witnesses are additional values that prove the correctness of the codewords. The equation shows that the commitment vector is a function of the hash values and the witnesses.</li><li><strong>(i,Ci)∈I</strong>*: This is a notation indicating a subset of indices and codewords. I* is a subset of [n], which is the set of all indices from 1 to n. For each index i in I*, there is a corresponding codeword Ci that is equal to C*, which is a fixed value that is not in the code. This notation implies that there are some positions in the matrix that have the same value C*, which is not consistent with the code function used to generate the codewords.</li><li><strong>h1,…,hn define C</strong>*: This is a statement implying that the hash values of the codewords determine the value of C*. This means that the hash function used to generate the hash values has a property that allows the sender to find a value C* that is not in the code, but has the same hash value as some of the codewords. This property can be exploited by the sender to cheat or equivocate in the commitment scheme.</li><li><strong>W in code</strong>: This is a statement implying that the witnesses are in the code. This means that the witnesses are values that are consistent with the code function used to generate the codewords. This property ensures that the witnesses can be verified by the receiver using the code function.</li><li><strong>Problem: Union Bound</strong>: The union bound is a technique that can be used to bound the probability of a union of events. In this context, the union bound can be used to bound the probability of a bad event, which is defined as follows:</li><li><em>Bad Event: There is I ⊆ [n] s.t. A. For all i ∈ I : Ci = C B. For all i ∈ I : Wi = RCi</em>*: This is a definition of the bad event that can occur in this construction. The bad event is that there exists a subset of indices I such that two conditions are satisfied: A. For all indices i in I, the codeword Ci is equal to C*, which is not in the code. B. For all indices i in I, the witness Wi is equal to RCi, where R is a matrix that represents the code function. The bad event means that the sender can open the commitment to values that are not consistent with the code function, and still pass the verification by the receiver. This violates the code binding property of the commitment scheme.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ajO-maAmk4cx-5S-RcnBKQ.png" /></figure><p>The sender encodes the data using an erasure code, which maps the data matrix X into a codeword matrix C using a generator matrix G. The codeword matrix C has k rows and n columns, where k is the number of original values and n is the number of encoded values.</p><ul><li>The sender commits to the codewords using a hash function, which maps each codeword ci into a hash value hi. The sender also computes a matrix R using another hash function, which maps the vector of hash values (h1,…,hn) into a matrix R. The sender then computes a vector W by multiplying the matrix R and the codeword matrix C. The vector W is a witness that proves the correctness of the codewords.</li><li>The sender also computes a subset of indices J using another hash function, which maps the vector of hash values and the vector of witnesses (h1,…,hn,W) into a subset J of [n]. The subset J determines which codewords will be revealed in the commitment. The sender then reveals the codewords corresponding to the indices in J, denoted by (Cj)j∈J.</li><li>The sender then sends the commitment vector com to the receiver, which consists of the vector of hash values, the vector of witnesses, and the revealed codewords: com = (h1,…,hn,W,(Cj)j∈J).</li><li>The receiver queries some positions of the data, and the sender responds with the corresponding codewords and openings. The receiver verifies the openings using the hash functions and the matrix R, and recovers the data values at those positions.</li></ul><p>This construction can achieve code binding, which means that the sender cannot open the commitment to values that are not consistent with the code function, by choosing the hash values at random. This is because the hash functions and the matrix R are unpredictable and depend on the hash values of the codewords, which are chosen at random. Therefore, the sender cannot find a value C* that is not in the code, but has the same hash value as some of the codewords, and can pass the verification by the receiver. This prevents the sender from cheating or equivocating in the commitment scheme.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KOvZ_wOK6UpbZQmSBhRkyQ.png" /></figure><ul><li>Reed-Solomon+KZG: This method uses Reed-Solomon codes, which are a type of linear codes that map the data into codewords using a polynomial function, and KZG commitments, which are a type of polynomial commitments that use pairings to commit and open the codewords. This method has the advantages of small proof size, fast verification, and homomorphic properties, but it requires a trusted setup and relies on cryptographic assumptions that may not be post-quantum secure12.</li><li>Tensor: This method uses tensor codes, which are a type of erasure codes that use tensor products to generate the codewords, and vector commitments, which are a type of functional commitments that use hash functions to commit and open the codewords. This method has the advantages of low encoding and decoding complexity, high reception efficiency, and better error correction capability, but it has large proof size and slow verification3 .</li><li>Hash-based: This method uses hash functions to map the data into codewords, and then interleaves the codewords to distribute the burst errors across multiple codewords. It also uses hash functions to commit and open the codewords. This method has the advantages of post-quantum security, no group exponentiations, and small global parameters, but it has large proof size and no homomorphic properties .</li></ul><p>Data availability sampling (DAS) is a technique that enables blockchain systems and other applications to verify and recover data in a scalable and secure way. However, DAS still has many challenges and open problems that need further research.</p><p>How can we create and commit to erasure codes that are efficient and secure?</p><p>How can we balance the trade-offs between proof size, verification time, and encoding complexity?</p><p>How can we deal with malicious behavior and network changes? How can we integrate DAS with other technologies, such as zero-knowledge proofs, sharding, and rollups?</p><h4>We hope that this blog has provided you with a clear and comprehensive overview of the basics of DAS, and has encouraged you to learn more and contribute to this exciting field.</h4><h4>In this next blog we will discuss why we need a data availability in a modular stack what is its proponents based on economical , social and security , larger blockspace manner</h4><p>😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a8033d8c9fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MEV, FLASHBOTS & SUAVE]]></title>
            <link>https://weufoundation.medium.com/mev-flashbots-suave-e1e28b6a3a42?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1e28b6a3a42</guid>
            <category><![CDATA[mev]]></category>
            <category><![CDATA[suave]]></category>
            <category><![CDATA[pbs]]></category>
            <category><![CDATA[flashbots]]></category>
            <category><![CDATA[ethereum-blockchain]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Sun, 31 Dec 2023 13:59:18 GMT</pubDate>
            <atom:updated>2023-12-31T14:00:25.629Z</atom:updated>
            <content:encoded><![CDATA[<p>WRITTEN BY — <a href="https://www.linkedin.com/in/fardeen-khan-093938212/">Fardeen Khan | LinkedIn</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6bOZ5Fs7eXZv-7gLqo6USQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*7EC0iEq3owZU7XAYfiDHaA.png" /></figure><p>Maximal extractable value (MEV) is the maximum profit that a miner or validator can make by including, excluding, or changing the order of transactions in a block on a blockchain network. MEV can affect the security, fairness, and efficiency of the network, as well as the user experience and fees. MEV can be extracted by various methods, such as front-running, back-running, sandwich attacks, and block stuffing. MEV is a phenomenon that exists on any blockchain that supports smart contracts, such as Ethereum.</p><p>Here we are going to discuss about these aspects in this blog where did mev come from , aspects around flashbots and mev opportunities and how the future looks like with SUAVE……</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/989/1*mlb-Eh2cMIS8wqXfmL98bQ.png" /></figure><p>The Flash Boys 2.0 paper is about the following components:</p><ul><li><strong>Arbitrage bots in decentralized exchanges (DEXes)</strong>: The paper documents and quantifies the widespread and rising deployment of arbitrage bots in blockchain systems, specifically in DEXes. These bots exploit inefficiencies in DEXes, paying high transaction fees and optimizing network latency to frontrun, i.e., anticipate and exploit, ordinary users’ DEX trades.</li><li><strong>Priority gas auctions (PGAs)</strong>: The paper observes that bots engage in what they call PGAs, competitively bidding up transaction fees in order to obtain priority ordering, i.e., early block position and execution, for their transactions. The paper formalizes and studies PGAs as a new continuous-time, partial-information, game-theoretic model.</li><li><strong>Miner extractable value (MEV)</strong>: The paper explains that PGAs are just one form of a general phenomenon in DEXes and beyond — what they call MEV — that poses concrete, measurable, consensus-layer security risks. The paper shows empirically that MEV poses a realistic threat to Ethereum today.</li></ul><p>The paper measures latency by putting various nodes among different countries and analyzing the propagation delays of transactions and blocks across the network. The paper also analyzes the arbitrage opportunities that they observed around the mempool, such as sandwich attacks, generalized frontrunning, and backrunning.</p><h4>Here is the paper link if you want to go more in depth of it — <a href="https://arxiv.org/pdf/1904.05234.pdf">1904.05234.pdf (arxiv.org)</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*qY61cbtjFqJdcIT3lLoWUQ.png" /></figure><p>This is specific to one case around reordering transactions within a slot.. Ordering optimization fees are the additional profits that a miner can make by manipulating the order of transactions in a block. For example, a miner can insert their own transaction before or after a user’s transaction to exploit a price difference or a market inefficiency. Ordering optimization fees are one form of miner extractable value (MEV), which is the general term for the value that miners can extract from the blockchain beyond the regular rewards and fees.</p><p>MEV creates a demand for experts in various fields, such as complexity, mathematics, and others, who can:</p><ul><li>Devise and examine methods to find, use, or stop MEV opportunities, such as arbitrage, liquidation, sandwich attacks, and block stuffing.</li><li>Build and apply protocols, mechanisms, or tools to reduce the negative impacts of MEV on the blockchain network’s security, fairness, and efficiency, such as Flashbots, MEV Auctions, and Fair Ordering Services.</li><li>Explore and model the effects of MEV on the actions and motivations of different actors in the blockchain ecosystem, such as miners, validators, users, developers, and regulators, from a game-theoretic, economic, and social perspective.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*XieFVRSYh5q0nvI8HhWiSw.png" /></figure><p>Flashbots was born out of the need to bring transparency, democratization, and sustainability to the MEV ecosystem, by providing core infrastructure and ecosystem tools that redefine the block production supply chain. Flashbots also conducts open and collaborative research on MEV market dynamics and blockchain design challenges. Flashbots’ vision is to enable a permissionless, transparent, and fair ecosystem for MEV, where anyone can participate and benefit from it .</p><h3>WHAT’S THE CURRENT SCENARIO AROUND FLASHBOTS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/937/1*e_55qjUWAx-B8LuiYDPp-A.png" /></figure><p>THESE ARE THE FEW PRODUCTS AROUND PBS and MEV market they had designed out:</p><ul><li><strong>Flashbots Protect</strong>: a transaction service that provides everyday Ethereum users frontrunning protection, transaction revert protection, configurable privacy and execution, and the ability to internalize the MEV they create.</li><li><strong>Flashbots MEV-Share Node</strong>: an instance of MEV-Share Node operated by Flashbots which enables MEV redistribution to the user, transaction flow originator, or any other destination. It does so by leveraging programmable privacy and a new standard for bundle construction: mev_sendBundle.</li><li><strong>Flashbots Bundle Relay</strong>: a unified entry point for searchers and other sophisticated users to access the Flashbots Builders and the Flashbots MEV-Share Node.</li><li><strong>Flashbots Builder</strong>: instances of MEV-Boost block builder operated by Flashbots in parallel. The block builders run algorithms and simulations to order bundles and transactions that maximizes profit and submit block bids to MEV-Boost Relay to compete for validators’ blockspace.</li><li><strong>Flashbots MEV-Boost Relay</strong>: an instance of MEV-Boost relay operated by Flashbots. MEV-Boost relays are a doubly-trusted data-availability layer and communication interface between block builders and validators, as part of the out-of-protocol implementation of the Proposer-Builder Separation (PBS).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/1*YXJo3G4vSpMvebv6WzBbUQ.png" /></figure><p>MEV Boost is a sidecar for the consensus client that allows validators to outsource block building to specialized entities known as block builders. Block builders optimize blocks for MEV extraction and fair distribution of rewards, and then submit their blocks to relays. Relays then deliver these blocks to validators, who can choose the best block to propose to the network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*47qGYAsEVlyonqqDiCRo-w.png" /></figure><p>The inclusion rate of MEV Boost is the percentage of blocks that are built by block builders and proposed by validators using MEV Boost. The higher the inclusion rate, the more MEV is captured and distributed by the MEV Boost ecosystem. According to Flashbots, the current inclusion rate of MEV Boost on the testnet is around 90%.</p><p>The validator payment is the proposer payment that the block builder makes to the validator for choosing their block. The validator payment is usually a fraction of the MEV extracted by the block builder, and it is determined by the market dynamics of supply and demand. The higher the validator payment, the more likely the validator will choose the block, but the lower the profit margin for the block builder. The validator payment is also affected by the latency and reliability of the relay, as well as the network congestion and gas prices.</p><p>MEV Boost is a way for validators to increase their profits from ETH staking by capturing MEV rewards, while also improving the security, fairness, and efficiency of the network. MEV Boost is expected to launch on the mainnet after the Ethereum merge to proof-of-stake.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*G3puDYIbTM8HkvZfDtSjWQ.png" /></figure><h3>CENSORSHIP IN THE MEV AND MORE ROBUST COMPETITIVE MEV-BOOST MARKET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*dzaDG2hu0ZHV8kx9gmNwZg.png" /></figure><blockquote>The cost of resilience paper is a research article published by Flashbots, a project that aims to illuminate, democratize, and distribute the MEV (maximal extractable value) generated by blockchains. The paper focuses on the issue of censorship in the MEV-Boost system, which is a new feature that allows validators to outsource the construction of high-MEV blocks to a network of relays and builders, while still building low-MEV blocks locally. The paper argues that this feature can increase the resilience of Ethereum by reducing the incentives for validators to censor transactions or collude with MEV actors, while only incurring a small opportunity cost in terms of forgone MEV revenue. The paper also proposes some design principles and mechanisms to mitigate the risks of censorship and centralization in the MEV-Boost system, such as inclusion lists, partial block auctions, and geographic diversity.</blockquote><blockquote>The paper can be found here: <a href="https://collective.flashbots.net/t/the-cost-of-resilience/756"><strong>The Cost of Resilience</strong></a><strong>.</strong></blockquote><h3>WHAT ABOUT DEMOCRATIZATION !!?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*oLy2EC8k7TpWK-zVpTbZSA.png" /></figure><p>Non-compliant OFAC transactions are transactions that involve entities or activities that are sanctioned by the U.S. Office of Foreign Assets Control (OFAC), such as Tornado Cash, a service that provides anonymity to users. Relays and builders are components of the MEV-Boost system, which is a feature that allows validators to outsource the construction of high-MEV blocks to specialized entities.</p><p>Relays and builders have different roles and incentives for non-compliant OFAC transactions. Relays are responsible for delivering blocks from builders to validators, and they can choose to censor or prioritize certain transactions based on their preferences or policies. For example, some relays may comply with OFAC sanctions and exclude non-compliant transactions, while others may ignore or defy them and include non-compliant transactions. Builders are responsible for optimizing blocks for MEV extraction and fair distribution of rewards, and they can choose to include or exclude certain transactions based on their profitability or risk. For example, some builders may seek to capture the MEV from non-compliant transactions, while others may avoid them due to legal or ethical concerns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*4V0hMDPdNHsjvj-v_a3hGg.png" /></figure><p>The effects of non-compliant OFAC transactions on the Ethereum network depend on the behavior and market share of relays and builders, as well as the response of validators and users. Some possible effects are:</p><ul><li><strong>Censorship</strong>: If most relays and builders comply with OFAC sanctions and exclude non-compliant transactions, this could reduce the accessibility and neutrality of the Ethereum network, as well as the user experience and fees45. This could also create a black market for non-compliant transactions, where users pay higher fees or use alternative channels to bypass censorship.</li><li><strong>Reorganization</strong>: If some relays and builders defy OFAC sanctions and include non-compliant transactions, this could increase the risk of chain reorganization, where validators or miners try to fork or rewrite the chain to capture or prevent MEV from non-compliant transactions. This could undermine the security and finality of the network, as well as increase the possibility of double-spending attacks.</li><li><strong>Centralization</strong>: If there is a high demand and low supply for non-compliant transactions, this could create a market imbalance and a power concentration for relays and builders that offer non-compliant transactions. This could lead to more collusion and corruption among MEV actors, as well as more barriers to entry and economies of scale for relays and builders.</li></ul><p>Non-compliant OFAC transactions pose a challenge for the Ethereum network, as they expose the trade-offs and tensions between security, fairness, efficiency, and sovereignty. There is no easy or definitive solution to this problem, but it requires careful and collaborative research and design from various stakeholders in the Ethereum ecosystem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/761/1*RhvQCHPbCyoBuIzRlpqxvw.png" /></figure><p>By open-sourcing the Flashbots relay and builder, the Flashbots project aims to achieve the following benefits for the MEV-Boost system:</p><ul><li><strong>Transparency</strong>: Open-sourcing the relay and builder allows anyone to inspect, audit, and verify the code and behavior of these components. This can increase the trust and confidence of the users, validators, and developers in the MEV-Boost system, as well as expose any potential bugs, vulnerabilities, or malicious activities.</li><li><strong>Democratization</strong>: Open-sourcing the relay and builder enables anyone to participate and contribute to the MEV-Boost system, either by running their own relay or builder, or by suggesting improvements or modifications to the existing ones. This can foster a more diverse and competitive MEV ecosystem, as well as encourage innovation and collaboration among different stakeholders.</li><li><strong>Sustainability</strong>: Open-sourcing the relay and builder ensures the long-term viability and resilience of the MEV-Boost system, as it reduces the dependence on any single entity or organization. It also allows the MEV-Boost system to adapt and evolve with the changing needs and preferences of the Ethereum community, as well as the regulatory and legal environment.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*jIXlY90iTbB-G84XzQkFwQ.png" /><figcaption>Bringing more robustness and competition by open sourcing the system</figcaption></figure><p>Regarding OFAC compliance, open-sourcing the relay and builder does not guarantee or enforce any specific policy or standard, as different relays and builders may have different views or approaches to dealing with non-compliant OFAC transactions. However, open-sourcing the relay and builder can facilitate the following outcomes:</p><ul><li><strong>Accountability</strong>: Open-sourcing the relay and builder can make it easier to monitor and measure the performance and behavior of these components, as well as to identify and report any violations or abuses of OFAC sanctions. This can help to deter or punish any bad actors, as well as to reward or incentivize any good actors.</li><li><strong>Choice</strong>: Open-sourcing the relay and builder can provide more options and flexibility for the users, validators, and developers to choose the relay and builder that best suit their needs and preferences, whether they are OFAC compliant or not. This can enhance the user experience and satisfaction, as well as the network efficiency and security.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*pd_AsOAa0Rqb7TPeFG1M8A.png" /></figure><h3>DISTRIBUTING THE MEV</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*EN8JHssuHe4GlPu-CrlK3Q.png" /></figure><p>Flashbots Protect is a service that allows Ethereum users to send their transactions to the Flashbots Network, which is a private mempool where MEV (maximal extractable value) is extracted and distributed in a transparent and fair way.</p><p>Flashbots Protect prevents frontrunning by sending your transaction to the Flashbots Network, which is a private mempool where MEV (maximal extractable value) is extracted and distributed in a transparent and fair way1. Your transaction will not be seen by bots that try to exploit your trade in the public mempool, and you will also get a share of the MEV that your transaction creates.</p><p>Flashbots Protect has the following benefits:</p><ul><li>Frontrunning protection: Your transaction will not be seen by bots that try to exploit your trade in the public mempool.</li><li>No failed transactions: Your transaction will only be included if it does not revert, so you do not pay for failed transactions.</li><li>MEV share: If your transaction creates MEV, you get up to 90% of it back as a refund.</li><li>Configurable: You can choose which builders and validators to send your transaction to, and how much tip to offer them.</li></ul><p>You can use Flashbots Protect by adding the Flashbots Protect RPC to your wallet, or by sending transactions using eth_sendRawTransaction or eth_sendPrivateTransaction to the Flashbots Protect RPC URL.</p><h3>STRUCTURE OF MEV MARKET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*vWeEj54e-CdqWwbrfBDwLQ.png" /></figure><p>Users are trying to minimize MEV because it can harm their interests, such as losing money, paying higher fees, or having their transactions delayed or censored. Validators are trying to maximize MEV because it can increase their rewards, such as getting more fees, capturing arbitrage opportunities, or preventing competitors from doing so.</p><p>Some possible solutions are:</p><ul><li>Encryption: Encryption can protect the privacy and integrity of transactions, making it harder for MEV actors to exploit them. For example, threshold encryption can be used to hide transactions until they are included in a block, preventing frontrunning and other attacks.</li><li>Decentralization: Decentralization can reduce the power and influence of MEV actors, making it more fair and secure for users. For example, decentralized multi-client functional encryption can allow multiple parties to generate and decrypt ciphertexts without relying on a trusted authority, enabling privacy-preserving computation on encrypted data.</li><li>Robustness: Robustness can increase the resilience and stability of the network, making it less vulnerable to MEV attacks. For example, proposer-builder separation can split the roles of block production and block validation, reducing the incentives and opportunities for validators to manipulate blocks.</li><li>Efficiency: Efficiency can improve the performance and scalability of the network, making it more user-friendly and cost-effective. For example, Flashbots Protect can allow users to send their transactions to a private mempool, where MEV is extracted and distributed in a transparent and fair way, avoiding failed transactions, high gas fees, and network congestion.</li></ul><h3>WTF IS SUAVE !!!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1010/1*FBeRVylWnt-vkfBRVLGd2g.png" /></figure><p>Suave by Flashbots is a new architecture for the MEV (maximal extractable value) ecosystem, which aims to decentralize and democratize the block building and ordering process across multiple blockchains. Suave is an EVM-compatible blockchain that serves as a common mempool and block builder network for any blockchain that supports smart contracts. Suave allows users, validators, and developers to express their value preferences and participate in a single unified auction for block space. Suave also enables cross-domain MEV extraction and distribution, which can increase the efficiency and security of the network, as well as the user experience and fees.</p><p><strong>You can learn more about Suave by Flashbots from their </strong><a href="https://writings.flashbots.net/the-future-of-mev-is-suave/"><strong>blog post</strong></a><strong> or their </strong><a href="https://medium.com/intotheblock/a-deep-dive-into-flashbots-suave-centauri-the-first-implementation-of-the-new-vision-for-mev-de72fa34ca70"><strong>whitepaper</strong></a><strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*_5IBWiRkvVYw4WylUiXvbQ.png" /></figure><h3>TRILLION DOLLAR PROBLEM</h3><ol><li><strong>The privacy / efficiency frontier in MEV</strong> is the trade-off between hiding and revealing information about transactions that create or affect MEV opportunities. On one hand, privacy can protect users from being exploited by MEV actors, such as frontrunners, backrunners, or sandwich attackers. On the other hand, efficiency can improve the speed and cost of transactions, as well as the fairness and security of the network.</li></ol><p>If the user reveals some kind of data about the trade, such as the amount, the price, the target, or the time, they may increase the efficiency of their transaction, but also expose themselves to MEV risks. For example, revealing the amount and price of a trade can help the user find the best execution venue and avoid slippage, but it can also attract arbitrageurs or sandwich attackers who can exploit the price difference or manipulate the market. Similarly, revealing the target or the time of a trade can help the user coordinate with other parties or optimize their gas fees, but it can also attract frontrunners or backrunners who can preempt or delay the user’s transaction.</p><p>However, some possible factors that can influence the user’s decision are:</p><ul><li>The type and size of the MEV opportunity: Some MEV opportunities are more competitive and profitable than others, which means they may require more privacy or efficiency to capture or prevent. For example, a large liquidation opportunity may attract more attention and competition than a small arbitrage opportunity, which means the user may need to hide more information or pay more fees to execute their transaction.</li><li>The risk and reward of the transaction: Some transactions are more risky and rewarding than others, which means they may involve more trade-offs and uncertainties. For example, a complex flash loan transaction may have more potential profit and loss than a simple swap transaction, which means the user may need to reveal more information or accept more delays to complete their transaction.</li><li>The trust and reputation of the parties: Some parties are more trustworthy and reputable than others, which means they may offer more guarantees and benefits. For example, a well-known and audited validator or builder may have more credibility and quality than a random or anonymous one, which means the user may be more willing to share more information or pay more fees to them.</li></ul><p>2. <strong>Geographical diversity </strong>can enhance censorship resistance around MEV (maximal extractable value) by reducing the latency and dependency of the network components, such as relays, builders, and validators.</p><p>By having relays, builders, and validators distributed across different regions and jurisdictions, the MEV ecosystem can achieve the following benefits:</p><ul><li><strong>Lower latency</strong>: Geographical diversity can reduce the network delays and communication overhead between relays, builders, and validators, which can improve the speed and efficiency of the MEV extraction and distribution process. This can also reduce the risk of chain reorganization, where validators or miners try to fork or rewrite the chain to capture or prevent MEV.</li><li><strong>Higher redundancy</strong>: Geographical diversity can increase the availability and resilience of the network components, as they can have backup or alternative options in case of failures or attacks. This can also improve the security and finality of the network, as well as the user experience and fees.</li><li><strong>Lower dependency</strong>: Geographical diversity can reduce the influence and control of any single entity or authority over the network components, as they can operate independently or collaboratively across different regions and jurisdictions. This can also enhance the fairness and sovereignty of the network, as well as the trust and confidence of the users, validators, and developers.</li></ul><p>Geographical diversity is one of the design principles and mechanisms that can help mitigate the negative effects of MEV on the Ethereum network, such as censorship, centralization, and instability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*Zs5qUBLij1Xh-FkL0ia-mg.png" /></figure><h4>3 HOW TO ESCAPE SGX ??</h4><p>SGX, or Software Guard Extensions, is a technology developed by Intel that allows applications to create secure enclaves, which are isolated regions of memory that are protected from external access or modification1. SGX can be used to implement private and permissionless MEV (maximal extractable value) auctions, where block builders can submit encrypted blocks to validators without revealing their contents or order.</p><p>To escape SGX in around MEV, one would need to either break the encryption or bypass the enclave. Breaking the encryption would require finding a vulnerability or a flaw in the SGX implementation or the encryption algorithm, which is unlikely and difficult. Bypassing the enclave would require finding a way to access or manipulate the memory or the CPU outside the enclave, which is also challenging and risky.</p><p>Therefore, escaping SGX in around MEV is not an easy task, and it would require a lot of resources, skills, and luck.</p><p><strong>THOUGH THERE IS AN BIG EXAMPLE OF FTX SITTING AROUND THE CORNER TOO…</strong></p><p>FTX was a cryptocurrency exchange that collapsed in November 2023 due to a lack of funds and a wave of customer withdrawals. The connection between MEV and FTX is that the volatility and chaos caused by FTX’s collapse increased the MEV opportunities and risks for the Ethereum network, where FTX operated. For example, the MEV rewards for Ethereum validators spiked as they tried to capture the arbitrage and liquidation profits from FTX’s downfall. However, this also increased the incentives and threats for chain reorganization, censorship, and centralization, which could undermine the security, fairness, and efficiency of the network.</p><p>MEV is the value from changing transactions.<br>But it can also cause problems and frictions.<br>For the users, the validators, and the network’s conditions</p><p>How can we reduce the harm and share the gain?<br>How can we make the blockchain more fair and humane?<br>There are some projects that offer solutions and explain</p><p>Suave lets users pay to prioritize their actions<br>Flashbots helps developers find and execute MEV extractions<br>Both projects aim to improve the network’s state<br>By making MEV transparent, fair, and great</p><p>HOPE YOU ABLE TO UNDERSTAND IN DEPTH WHAT ARE THE MEV PROBLEMS RELIES AROUND USERS, BUILDERS, RELAYS AND PROPOSERS. AT THE SAME TIME FEW SOLUTIONS PROVIDED BY FLASHBOTS AND OTHERS TO SOLVE PROBLEMS AROUND MEV. FEEL FREE TO QUESTION IN THE COMMENT BOX, WOULD LOVE TO HELP YOU OUT DESIGNING THE SYSTEMS AROUUND PBS …..</p><p>HAPPY NEW YEAR!!!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1e28b6a3a42" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PROPOSER BUILDER SEPARATION AT PROTOCOL LEVEL]]></title>
            <link>https://weufoundation.medium.com/proposer-builder-separation-at-protocol-level-a73408ae0adf?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a73408ae0adf</guid>
            <category><![CDATA[mev-boost]]></category>
            <category><![CDATA[pbs]]></category>
            <category><![CDATA[mev]]></category>
            <category><![CDATA[ethereum-blockchain]]></category>
            <category><![CDATA[incentive-compatibility]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Sat, 30 Dec 2023 11:27:53 GMT</pubDate>
            <atom:updated>2023-12-30T12:12:26.958Z</atom:updated>
            <content:encoded><![CDATA[<p>WRITTEN BY — FARDEEN KHAN — <a href="https://www.linkedin.com/in/fardeen-khan-093938212/">Fardeen Khan | LinkedIn</a></p><p>JOIN OUR RESEARCH BASED OPEN SOURCE COMMUNITY FROM HERE — <a href="http://linktr.ee/weufoundationsocial">http://linktr.ee/weufoundationsocial</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s_cTkZjlFXwSYs2JX1cFbg.png" /><figcaption>IT’S ALL ABOUT BLOCK CONSTRUCTION</figcaption></figure><p>WE ARE GOING TO DISCUSS AROUND THESE MAJOR TOPICS IN THIS BLOG….</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*T16NTsN_9Uwk1p3IGRF-1w.png" /></figure><h3>BLOCK CONSTRUCTION IN ETHEREUM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*qnB1HtsYRzw_qf6ilOMTTQ.png" /></figure><p>A blockchain is a data structure that stores a sequence of transactions in a secure and decentralized way. Each transaction is grouped into a block, which contains a unique identifier (hash), a reference to the previous block (previous hash), and other metadata. The blocks are linked together by their hashes, forming a chain of blocks. This chain is verified and maintained by a network of nodes that follow a consensus protocol. The blockchain data structure ensures that the transactions are immutable, transparent, and verifiable.</p><p>HEAD AND BODY OF A BLOCK… SAME LIKE OUR BODY SYNAPSE SOME INFORMATION AND THE WHOLE BODY EXECUTE IT.</p><ul><li><strong>Block header</strong>: This is the metadata of the block, which includes the block number, the timestamp, the hash of the previous block, the hash of the current block, and the consensus data. The consensus data is the information that is used by the consensus algorithm to validate the block and reach an agreement among the nodes. For example, in proof-of-work, the consensus data is the nonce and the difficulty, which are used to solve the cryptographic puzzle. In proof-of-stake, the consensus data is the stake and the signature, which are used to prove the ownership and validity of the block.</li><li><strong>Block body</strong>: This is the payload of the block, which contains the executable transactions. Transactions are the records of data transfer or state change that occur on the blockchain network. Transactions are usually signed by the sender and verified by the receiver. Transactions can also contain smart contracts, which are self-executing programs that define the rules and logic of the transactions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*GgwVd2OFmmMFIxZ9u_sSpA.png" /></figure><p>In proof-of-stake, validators and block builders are separated. Validators are the ones who stake their Ether and run nodes to secure the network. They are randomly selected to propose blocks and attest to their validity. Block builders are the ones who collect and order transactions from the mempool and submit them to the validators. They are rewarded by the fees paid by the users for their transactions. This system is more scalable, secure, and fair, as it reduces the barriers to entry, the environmental impact, and the influence of block builders over transaction ordering.</p><p>The consensus client implements the new consensus algorithm, which enables the network to achieve agreement based on validated data from the execution client. The execution client continues to run the EVM and process transactions as before, but now receives block proposals from the consensus client instead of miners. This modular design makes the network more scalable, secure, and efficient, as it reduces the complexity and dependency of each component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*CKTPdnC-x5E88-3q6JKIFQ.png" /></figure><p>A block proposer in Ethereum is a validator who is randomly selected to propose a new block for the network. The block proposer has to take care of the execution payload, which is the set of transactions that will be executed by the EVM and change the state of the network. The execution payload has to be valid, meaning that it follows the rules of the network and does not contain any invalid or conflicting transactions.</p><p>The block proposer also has to consider the constraint of the base fee, which is the minimum gas price that a transaction must pay to be included in a block. The base fee is determined by the network and adjusts dynamically according to the demand for block space. The base fee is burned, meaning that it is removed from the total supply of Ether and does not go to the block proposer or any other validator.</p><p>The block proposer has to balance the trade-off between maximizing their profit and ensuring the security and efficiency of the network. On one hand, the block proposer wants to include as many transactions as possible in their block, especially those that pay a high priority fee (also known as the miner tip), which is the additional fee that goes directly to the block proposer. On the other hand, the block proposer does not want to create a block that is too large or too small, as this could affect the base fee and the network congestion in the future. A block that is too large could increase the base fee and discourage users from sending transactions, while a block that is too small could decrease the base fee and encourage spamming or manipulation of the network.</p><p>Therefore, the block proposer has to estimate the optimal size and composition of their block, taking into account the current and expected base fee, the priority fees of the transactions in the mempool, and the gas limit of the network. The block proposer can use various strategies and heuristics to do this, such as sorting the transactions by their effective gas price (the sum of the base fee and the priority fee), filtering out the transactions that are below a certain threshold, or using a dynamic algorithm that adjusts the block size and the priority fee according to the market conditions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*6OTJcUFC-OV9S-M_djsZ_w.png" /></figure><p>From MINER EXTRACTABLE VALUE (POW) to MAXIMAL EXTRACTABLE VALUE ….BLOCK PROPOSER IS THE BEST PLACE TO CAPTURE THE MAXIMUM VALUE .</p><p>Ordering matters for block proposers because it affects the amount of maximal extractable value (MEV) they can obtain from the transactions in a block. MEV is the extra profit that block proposers can earn by manipulating the inclusion, exclusion, or reordering of transactions in a block, in addition to the regular block reward and gas fees.</p><p>Block proposers act upon MEV by trying to find the optimal order of transactions that maximizes their revenue, while also considering the trade-offs and risks involved. For example, some transactions may have higher priority fees (also known as miner tips) that go directly to the block proposer, while others may have lower priority fees but create arbitrage or liquidation opportunities for the block proposer or other searchers (independent actors who look for MEV opportunities and submit them to the network). Block proposers may also try to front-run, back-run, or sandwich other transactions to exploit price differences or market inefficiencies.</p><h3><strong>PBS IN PRACTICE</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*EBLAuBq28SJoWC_vFh9kQw.png" /></figure><p>In proof-of-work based systems, the searcher and proposer relation works as follows:</p><ul><li>A<strong> searcher</strong> is an independent actor who looks for profitable MEV opportunities, such as arbitrage, liquidation, or front-running, by analyzing the transactions in the mempool or the blockchain.</li><li>A <strong>proposer</strong> is a miner who competes to create new blocks filled with processed transactions, by solving a cryptographic puzzle that requires a lot of computational power.</li><li>A searcher can submit a transaction that executes an MEV opportunity to a proposer, along with a high priority fee (also known as the miner tip) that goes directly to the proposer. The priority fee is the additional fee that a user pays on top of the base fee, which is the minimum gas price that a transaction must pay to be included in a block.</li><li>A proposer can choose to include the searcher’s transaction in their block, and order it in a way that maximizes the MEV profit. The proposer can also share a portion of the MEV profit with the searcher, as an incentive for them to reveal the MEV opportunity.</li><li>Alternatively, a proposer can act as a searcher themselves, and find and execute MEV opportunities on their own, without paying any priority fee or sharing any profit with anyone else.</li></ul><p>SIMPLY , IT’S ALL ABOUT TRUST HERE AS WELL -</p><p>Mining pools are groups of miners who pool their resources and share the rewards of mining blocks in a proof-of-work (PoW) system. Mining pools allow miners to increase their chances of finding a valid block and reduce the variance of their income. Mining pools also act as intermediaries between searchers and proposers, who are the actors that look for and execute MEV opportunities in a PoW system. Searchers can trust mining pools to include their transactions in a block and share the MEV profit with them, as long as the mining pool has a good reputation and a large market share</p><p>The relation between searchers and proposers in proof-of-work systems relies on trust, and that there is a possibility of manipulation. For example, a proposer could cheat a searcher by accepting their transaction but not including it in their block, or by reordering the transactions in their block to benefit themselves. A searcher could also cheat a proposer by submitting a transaction that does not execute the MEV opportunity as promised, or by withholding a transaction that could prevent a loss for the proposer.</p><p>However, there are also some factors that discourage manipulation and encourage cooperation between searchers and proposers. For instance, a proposer who cheats a searcher may lose their reputation and future business opportunities, as the searcher could blacklist them or report them to other searchers. A searcher who cheats a proposer may lose their chance to earn MEV profit, as the proposer could reject their transaction or prioritize other transactions. Moreover, both searchers and proposers have to compete with other actors in the network, who may offer better deals or faster execution. Therefore, it may be more rational and profitable for searchers and proposers to cooperate and share the MEV profit, rather than manipulate and risk losing it.</p><h3><strong>PBS IN PRACTICE</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*tf9HrTrdIAGmtZjgW1Na-Q.png" /><figcaption>where builders comes in picture</figcaption></figure><p>The problem of solo validators in a PoS system is that they have a lower chance of being selected as proposers and earning rewards, compared to validators who join a pool or a service. This is because the probability of being selected as a proposer is proportional to the amount of stake, and solo validators usually have less stake than pooled validators. Solo validators also have to bear the costs and risks of running their own nodes, such as hardware, software, security, and availability. Moreover, solo validators have less bargaining power and influence over MEV extraction, compared to pooled validators. This is because solo validators have less control over the order and inclusion of transactions in a block, and they have to compete with other searchers and proposers who may offer better deals or faster execution .</p><p>The role of builders in the proof of stake based chains is to collect and order transactions from the mempool and submit them to the proposers, who are the validators that are randomly selected to create new blocks. Builders are rewarded by the fees paid by the users for their transactions. Builders interact with the proposers by sending them bundles, which are sets of transactions that execute MEV opportunities, along with a bid for their inclusion in a block. Proposers can choose to accept or reject the bundles, and order them in a way that maximizes their revenue, while also considering the trade-offs and risks involved. Proposers can also share a portion of the MEV profit with the builders, as an incentive for them to reveal the MEV opportunities.</p><p>However , proposers cannot steal the content of the blocks that the builder has given to them, because they only see the bundle headers, not the bundle bodies, until they have already selected the header that wins the auction. A bundle is a set of transactions that execute MEV opportunities, along with a bid for its inclusion in a block. A bundle header contains the hash of the bundle body, the bid, and the signature of the builder. A bundle body contains the ordered list of transactions and the proof of validity. If the proposer tries to change the content of the block, they will invalidate the hash and the signature, and the block will be rejected by the network.</p><p>HOW THIS RELATION BETWEEN BUILDER &amp; PROPOSER IS DONE USING A SOFTWARE PIECE ….</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*oFlLHILG0sRUrpmhsDZnGg.png" /></figure><p>MEV-Boost is a software that allows Ethereum validators to access a competitive block-building market. MEV-Boost is an implementation of proposer-builder separation (PBS) for proof-of-stake (PoS) Ethereum. With MEV-Boost, validators can source blocks from a marketplace of builders, who optimize the order and inclusion of transactions to extract maximal extractable value (MEV). MEV-Boost is free, open-source, neutral software built by Flashbots for the community.</p><p>Relays are intermediaries that receive blocks from builders and forward them to proposers. Builders are the ones who collect and order transactions to extract maximal extractable value (MEV). Proposers are the validators who are randomly selected to create new blocks. Relays are trusted by both builders and proposers for fair routing, validity, accuracy, and data availability. Relays also verify and simulate the blocks sent by the builders, and rate-limit them as necessary. <a href="https://docs.flashbots.net/flashbots-mev-boost/relay">Relays can connect to one or many builders, and aggregate their bids for the proposers</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*Fa9zoeLi5_DAyVfESsxtjg.png" /></figure><ul><li>Building blocks with MEV-Boost allows validators to access a competitive market of block builders, who optimize the order and inclusion of transactions to extract maximal extractable value (MEV). <a href="https://blog.merkle.io/blog/mev-and-block-building-part-1">MEV is the extra profit that validators can earn by manipulating the transactions in a block, such as frontrunning, backrunning, or arbitraging</a>.</li><li>Building blocks with MEV-Boost reduces the complexity and dependency of each component in the system. Validators only need to run a consensus client and an MEV-Boost client, while block builders only need to run an execution client and a builder client. <a href="https://blog.merkle.io/blog/mev-and-block-building-part-1">This modular design makes the system more scalable, secure, and efficient</a>.</li><li>Building blocks with MEV-Boost improves the fairness and transparency of the network. Validators can choose the best block from a pool of bids submitted by block builders, and share the MEV profit with them. <a href="https://blog.merkle.io/blog/mev-and-block-building-part-1">Block builders can also use the standard Ethereum Builder API, which defines the interface between validators and block builders</a>.</li></ul><h3><strong>PBS IN THEORY</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*Oo2We88c4dCr4_oHOOL4Ng.png" /></figure><p>As you can see there is no relays in between the builder and the proposer . SO in the future we can see a direct relation between the builder and the proposer…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*Pi2vaUCcDMS3VsONqajTBA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*Grm0TWiaurQ6a2HZvlxbGQ.png" /></figure><p>Block building is usually more costly than block verification, because it involves finding and executing transactions that maximize the profit of the block builder, such as maximal extractable value (MEV) opportunities. <a href="https://bitcoin.stackexchange.com/questions/12333/what-is-the-block-verification-procedure-and-will-it-ever-become-too-expensive">MEV is the extra profit that can be earned by manipulating the transactions in a block, such as frontrunning, backrunning, or arbitraging</a>. <a href="https://nvlpubs.nist.gov/nistpubs/ir/2018/NIST.IR.8202.pdf">Block building also requires solving a cryptographic puzzle or proving the stake in some consensus protocols, such as proof-of-work (PoW) or proof-of-stake (PoS)</a>.</p><p>Block verification is usually less costly than block building, because it only involves checking the hash, signature, and rules of the block, without executing the transactions or solving the puzzle. <a href="https://www.section.io/engineering-education/blockchain-consensus-protocols/">Block verification can be done by any node in the network, while block building can only be done by a selected node or a group of nodes, depending on the consensus protocol</a>.</p><p>The idea behind making the computation of block building costly and block verification cheap is to create an asymmetry that results in more accessible and more resistant blocks. The asymmetry makes it easier for the network to reach a consensus and verify the transactions, while making it harder for the attackers to alter or invalidate the blocks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*FJcJkNrIujAbmlDoFBmLvA.png" /></figure><p>If we implement PBS in the protocol structure itself, some of the changes that may come to the PBS relation are:</p><ul><li>The protocol may define a standard interface and a bidding mechanism for block builders and validators to communicate and cooperate. <a href="https://www.thoughtco.com/phosphate-buffered-saline-pbs-solution-4061933">This may increase the efficiency and fairness of the block building market, and reduce the dependency on intermediaries or third-party services</a>.</li><li>The protocol may enforce some rules or incentives for block builders and validators to share the MEV profit and prevent manipulation or collusion. This may improve the security and decentralization of the network, and reduce the negative externalities of MEV extraction .</li><li>The protocol may introduce some features or innovations that enhance the performance and functionality of the block building process, such as parallelism, sharding, or rollups. This may increase the scalability and throughput of the network, and enable more complex and diverse transactions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*Mg3tFPobSSGGp4lg0I1PpQ.png" /></figure><ul><li>Slot auctions are a way of allocating block space to external block builders who bid for the right to make a block on behalf of the block proposer.</li><li>Slot auctions can be either block auctions or slot auctions. Block auctions require the block builder to commit to a specific block content before sending a bid to the block proposer. Slot auctions only require the block builder to commit to a bid and reveal the block content later.</li><li>Block auctions have the advantage of being more transparent and verifiable, as the block proposer can check the validity and value of the block before accepting it. Slot auctions have the advantage of being more flexible and efficient, as the block builder can optimize the block content until the last moment and avoid revealing it to potential competitors.</li><li>Block auctions may be more suitable for scenarios where the block proposer wants to impose some constraints or preferences on the block content, such as inclusion lists or partial block auctions. Slot auctions may be more suitable for scenarios where the block proposer wants to maximize their revenue by accepting the highest bid without caring about the block content.</li></ul><h3><strong>SOLVING ISSUES AROUND PBS</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*21WQVWEq-fzjxXj3277REw.png" /></figure><p>The principal-agent problem in PBS (proposer-builder separation) is the conflict of interests between the proposers and the builders, who are the actors that create and order transactions in a block.</p><p>One way to solve the principal-agent problem in PBS is to use partial block making by the proposer, which means that the proposer can reserve some space in the block for their own transactions, and only auction off the remaining space to the builder. <a href="https://www.wallstreetmojo.com/principal-agent-problem/">This way, the proposer can ensure that some transactions that they care about are included in the block, and also reduce the power and profit of the builder</a>.</p><p>Another way to solve the principal-agent problem in PBS is to use inclusion list by the builder, which means that the builder can provide a list of transactions that they guarantee to include in the block, along with their bid. The proposer can then choose the best bid based on the inclusion list and the price. <a href="https://www.pivothomes.com.au/building/comparing-builders-inclusions-lists-the-complete-guide/">This way, the proposer can have some control over the block content, and also increase the transparency and fairness of the block building market</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*RM6HXNobwYvyxTj_hOHIpQ.png" /></figure><p>Data availability is the property that ensures that the data of a block is accessible and verifiable by anyone in the network. <a href="https://polynya.medium.com/danksharding-36dc0c8067fe">Data availability is essential for the security and scalability of blockchain systems, especially for layer 2 solutions such as rollups, which rely on the data of the layer 1 chain to execute and validate transactions</a>.</p><p>Builders for data availability can be outsourced by using services or protocols that provide data availability solutions for blockchains. For example, some services offer data availability as a service (DAAS), which means that they store and serve the data of the blocks for a fee. Some protocols use erasure coding or Reed-Solomon codes, which means that they encode the data of the blocks into smaller pieces and distribute them across the network, so that the data can be reconstructed from a subset of the pieces. <a href="https://polynya.medium.com/danksharding-36dc0c8067fe">Some protocols use fraud proofs or data availability proofs, which means that they allow anyone to challenge the availability or validity of the data of the blocks, and penalize the malicious actors</a>.</p><p>One way to solve the data availability problem with danksharding is to use the KZG scheme, which is a technique that reduces the data of a block to a small cryptographic commitment. The commitment can be verified by anyone in the network, without requiring the full data of the block. The KZG scheme also allows for efficient data availability proofs, which means that anyone can prove that they have the data of the block, or that the data of the block is unavailable or invalid. The KZG scheme is compatible with zero-knowledge techniques, which are used by some rollups and other parts of the Ethereum protocol.</p><p><strong>WHICH WE WILL DISCUSS IN ANOTHER VOLUME OF PROPOSER BUILDER SEPARATION</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/993/1*izByQmiiJcXEiaamL9Fzow.png" /></figure><p>Incentive compatibility is a property of mechanisms that aligns the individual interests of the participants with the collective interests of the system. <a href="https://collective.flashbots.net/t/incentive-compatibility-in-pbs-program-synthesis-and-type-theory-of-preferences/914">Incentive compatibility ensures that each participant can achieve the best outcome for themselves by following the rules of the mechanism, regardless of what the others do</a>.</p><p>Incentive compatibility of PBS is desirable because it promotes the security, efficiency, and fairness of the network. However, it is also challenging because of the potential conflicts and trade-offs between the proposers and the builders, who may have different preferences and objectives. For example, proposers may want to include some transactions that they care about, while builders may want to exclude or reorder them to maximize MEV. <a href="https://collective.flashbots.net/t/incentive-compatibility-in-pbs-program-synthesis-and-type-theory-of-preferences/914">Proposers may also want to have some control or transparency over the block content, while builders may want to keep it secret or flexible</a>.</p><p>There are several approaches and solutions to achieve incentive compatibility of PBS, such as:</p><ul><li>Using partial block making by the proposer, which means that the proposer can reserve some space in the block for their own transactions, and only auction off the remaining space to the builder. This way, the proposer can ensure that some transactions that they care about are included in the block, and also reduce the power and profit of the builder.</li><li>Using inclusion list by the builder, which means that the builder can provide a list of transactions that they guarantee to include in the block, along with their bid. The proposer can then choose the best bid based on the inclusion list and the price. This way, the proposer can have some control over the block content, and also increase the transparency and fairness of the block building market.</li><li>Using dominant-strategy incentive-compatible (DSIC) or Bayesian-Nash incentive-compatible (BNIC) mechanisms, which means that the mechanism design ensures that truth-telling or bidding is the best strategy for both the proposer and the builder, regardless of what the others do (DSIC) or given what the others do (BNIC). <a href="https://collective.flashbots.net/t/incentive-compatibility-in-pbs-program-synthesis-and-type-theory-of-preferences/914">This way, the mechanism can achieve the optimal social choice function or outcome for the network</a>.</li></ul><p><strong>WHICH WE WILL DISCUSS IN ANOTHER VOLUME OF PROPOSER BUILDER SEPARATION</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*KrALU4QBZcDtiQCWrT5NMQ.png" /></figure><p>PBS may introduce some challenges and trade-offs between the proposers and the builders, who may have different preferences and objectives. For example, proposers may want to include some transactions that they care about, while builders may want to exclude or reorder them to maximize MEV. <a href="https://link.springer.com/article/10.1057/s41264-021-00133-w">Proposers may also want to have some control or transparency over the block content, while builders may want to keep it secret or flexible</a>.</p><p>PBS may expose the users to various attack vectors, such as censorship, front-running, and bribing, that may compromise the security and fairness of the network. <a href="https://link.springer.com/article/10.1057/s41264-021-00133-w">Users may also face higher fees or lower priority for their transactions, depending on the market conditions and the bids of the block builders</a>.</p><p>PBS may require some changes or adaptations in the user interface and the user experience, as it introduces a new layer of abstraction and complexity in the block building process</p><p><strong>WHICH WE WILL DISCUSS IN ANOTHER VOLUME OF PROPOSER BUILDER SEPARATION</strong></p><h4><strong>“PBS: a game-changer for blockchains. It splits block creation and block proposal, making censorship harder, MEV lower, and scalability higher.”</strong></h4><h3>HOPE YOU LIKE THE BLOG AROUND BLOCK CONSTRUCTION AND PBS . SHARE WITH YOUR FRIENDS TO THINK AROUND THIS NEW MARKET WHERE MORE APPLICATIONS CAN BE CREATED . AS WEU FOUNDATION IS AGGRESIVELY WORKING TO CREATE A DEVELOPMENT , SECURITY BASED AND CAPITAL EFFICIENT MARKETPLACE BASED BLOCKCHAIN AROUND THESE PROBLEMS . MAJORILY SOLVING A PROBLEM AROUND BLOCKSPACE FUTURES.</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a73408ae0adf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[It’s All About Trust]]></title>
            <link>https://weufoundation.medium.com/its-all-about-trust-f8abc3335e5f?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8abc3335e5f</guid>
            <category><![CDATA[consensus]]></category>
            <category><![CDATA[its-all-about-trust]]></category>
            <category><![CDATA[layer-2-technology]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[direct-acyclic-graph]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Wed, 22 Nov 2023 10:14:42 GMT</pubDate>
            <atom:updated>2023-11-22T13:24:15.813Z</atom:updated>
            <content:encoded><![CDATA[<p>Written by — Fardeen khan (<a href="https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app">https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app</a> )</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*98BaH6jr7DqtJHnw8jX-jg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KA81R4l4HujZ9ey1oAbxzQ.png" /></figure><p>Cryptography, distributed computing and economics are three key aspects of blockchain technology that play a role in improving the existing trust system around blockchains. Here is a brief overview of how they do so:</p><ul><li>Cryptography: Cryptography is the science of securing information using mathematical techniques. Cryptography enables blockchains to protect the data stored in the ledger from unauthorized access, modification or deletion. Cryptography also allows blockchains to verify the identity and authenticity of the participants and transactions in the network. For example, blockchains use cryptographic hash functions to generate unique identifiers for each block and transaction, and digital signatures to ensure that only the rightful owners can spend their coins or tokens.</li><li>Distributed computing: Distributed computing enables blockchains to operate in a decentralized manner, without relying on a central authority or intermediary. Distributed computing also allows blockchains to achieve consensus among the nodes in the network, which means that they can agree on the state and validity of the ledger. For example, blockchains use various consensus algorithms, such as proof-of-work, proof-of-stake, proof-of-authority, etc., to coordinate the nodes and prevent malicious attacks or forks.</li><li>Economics: Economics is the social science that studies how people make decisions and interact in the context of scarcity and incentives. Economics influences blockchains in terms of designing the rules and mechanisms that govern the behaviour and outcomes of the participants and transactions in the network. Economics also affects blockchains in terms of evaluating the costs and benefits of using the technology, as well as the potential impacts and implications on the society and the environment. For example, blockchains use economic models, such as game theory, mechanism design, incentive engineering, etc., to align the interests and actions of the nodes and users, and to ensure the security and efficiency of the system.</li></ul><h4>But with that there is an important role of governance too</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E7z55yPAj4NbSCHwzsejHQ.png" /></figure><p>Governance is the process of setting and enforcing the rules for a distributed system. Governance plays a role in improving the trust system around blockchains by:</p><ul><li>Coordinating the actions and decisions of the participants, such as nodes, users, developers, etc.</li><li>Protecting the system from internal and external threats, such as attacks, fraud, censorship, etc.</li><li>Ensuring the long-term viability and adaptability of the system, by providing incentives for the participants to contribute and evolve.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s7HlSzr9KWcclRsTNfpJ_A.png" /><figcaption>For an incentivized Trust system at scale, we use blockchains. They carry a capability of coordination at scale.</figcaption></figure><h4>Famous quotes from Yuval Noah Harari (Kind of carrying deep and integrated beliefs carrying about how the world works)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ROgoAOdS6WmkAbIO919kUw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H-2fA0bLcQqBjmrR-zwz-A.png" /></figure><p>At last, I want to end by adding few of thoughts that by building incentivizing distributed systems for trusted coordination at scale . We are upbringing the society which are rejected by the organisations, governments, social norms can participate in this system and coordinate with other to do some of the work and get incentivized for mantaining the trust in the system .</p><h3>Decentralized flywheel around trusted coordinated systems</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6tWbK3M3iqb5Cq9T4kpejA.png" /></figure><p>The idea of the decentralized flywheel is that once it is set in motion, it gains momentum and becomes more robust and scalable over time, creating a virtuous cycle of growth and innovation for the network and its participants.</p><p>Will discuss around the mental model around blockchains || Then how blockchains, Systems and Theory cope with each other in the paradigm of incentivized distributed systems at scale while the flywheel be around Consensus designs, DAGs and L2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aGBynpLEGutJqjNz2upg_A.png" /></figure><h4>Will be mainly focus around SMR and the Execution layer.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JRQhtqZyX5pHL47w_n_WXw.png" /></figure><p>As the ideal system don&#39;t exist in the real world, how we can provide an ideal system to client is by providing a system that is safe, live and privacy based at large coordination level.</p><h4>What are the challenges faced by blockchains or SMR in terms of Scalability?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ec_wb1NOfJhP8mFxi1pm4Q.png" /></figure><h4>So basically, if you look towards INPUT, EXECUTION AND OUTPUT it will look a representation of normal computer or server like AWS which get data, it executes it and then produces the OUTPUT.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AVwhZKPv61n98vi86rX_LQ.png" /></figure><p>SMR consists of four main steps: input, ordering, execution, and output. Each of these steps can potentially become a bottleneck for the system, depending on the workload, the network, and the resources available. Here are some possible causes and solutions for each bottleneck:</p><h3>Input:</h3><h4>This is the step where the system receives requests from the clients or external sources. A bottleneck can occur here if the system cannot handle the incoming traffic or if the data availability is low. Some possible solutions are:</h4><ul><li>Load balancing: This is the process of distributing the workload among multiple servers or nodes, to avoid overloading a single point of entry. Load balancing can improve the performance and reliability of the system, by reducing the response time and increasing the fault tolerance.</li><li>Data sharding: This is the process of splitting the data into smaller and independent chunks, called shards, and storing them across different servers or nodes. Data sharding can improve the data availability and scalability of the system, by reducing the data size and increasing the parallelism.</li></ul><h3>Ordering:</h3><h4>This is the step where the system determines the order of the requests, to ensure consistency and correctness. A bottleneck can occur here if the system cannot reach consensus among the nodes or if the communication complexity is high. Some possible solutions are:</h4><ul><li>Consensus algorithm: This is the algorithm that the system uses to achieve agreement among the nodes on the order and validity of the requests. Different consensus algorithms have different trade-offs in terms of speed, security, and scalability. For example, proof-of-work is a consensus algorithm that is secure but slow and costly, while proof-of-stake is a consensus algorithm that is fast but less decentralized and more vulnerable to attacks.</li><li>Communication protocol: This is the protocol that the system uses to exchange messages among the nodes, to coordinate the ordering process. Different communication protocols have different trade-offs in terms of efficiency, reliability, and overhead. For example, broadcast is a communication protocol that is simple but wasteful and prone to collisions, while multicast is a communication protocol that is selective but complex and dependent on the network topology.</li></ul><h3>Execution:</h3><h4>This is the step where the system executes the requests, according to the order determined by the ordering step. A bottleneck can occur here if the system cannot process the requests fast enough or if the computational power is limited. Some possible solutions are:</h4><ul><li>Parallel processing: This is the process of executing multiple requests simultaneously, by using multiple processors or cores. Parallel processing can improve the throughput and speed of the system, by exploiting the concurrency and reducing the idle time.</li><li>Hardware optimization: This is the process of improving the performance and capacity of the hardware components, such as the CPU, the memory, the disk, etc. Hardware optimization can improve the efficiency and functionality of the system, by reducing the latency and increasing the storage.</li></ul><h3>Output:</h3><h4>This is the step where the system delivers the results of the requests to the clients or external sources. A bottleneck can occur here if the system cannot send the results fast enough or if the network bandwidth is low. Some possible solutions are:</h4><ul><li>Compression: This is the process of reducing the size of the results, by using various techniques, such as lossless or lossy compression, encryption, encoding, etc. Compression can improve the transmission and storage of the results, by saving the network bandwidth and the disk space.</li><li>Caching: This is the process of storing the results in a temporary memory, such as the RAM, the cache, or the buffer, for faster access and retrieval. Caching can improve the responsiveness and availability of the system, by reducing the access time and the network traffic.</li></ul><p>WITHOUT CONSENSUS IT THOUGH LOOK LIKE A NORMAL COMPUTER INSTEAD OF DISTRIBUTED COMPUTER. SO MAINLY WE ARE GOING TO TALK AROUND THE PROBLEM OF CONSENSUS WHICH COME AROUND -</p><p>As per consensus layer what we are doing a consensus on is a digest of data if the data is available at full by some node . The consensus client dont have to agree or see the whole data , it can agree on that polynomial commitment send by the execution layer and if some clients wants to check the data truthness and realibilty it can go to the data availability layer to check it out .</p><h4>LATENCY vs THROUGHPUT</h4><p>Latency is the time it takes for a data packet to travel from the source to the destination, while throughput is the amount of data that can be transferred over a network in a given period of time. These two metrics are influenced by various factors, such as the network bandwidth, the network delay, the transaction execution, and the communication complexity.</p><p>Generally speaking, there is an inverse relationship between latency and throughput, meaning that as one increases, the other decreases. For example, if a system tries to increase its throughput by sending more data packets at once, it may also increase its latency, as the network may become congested, and the packets may take longer to reach their destination. Conversely, if a system tries to decrease its latency by sending fewer data packets at a time, it may also decrease its throughput, as the network may become underutilized, and the data transfer rate may drop.</p><p>However, this trade-off is not always linear or fixed, as there may be ways to optimize or balance the latency and throughput of a system, depending on the context and the requirements.</p><h4>A bit around bitcoin (Pow ) and modern blockchain system using quorum based BFT.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4aiij87WVzTHS5uqq-NJUg.png" /></figure><h3>QUORUM BASED CONSENSUS FLYWEEL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qw3wCUkZdMqoreSjnpy-iA.png" /></figure><p>Asynchronous, partial synchrony, and Paxos are concepts related to distributed systems and consensus algorithms. Here is a brief explanation of each concept and how Paxos has changed the paradigm of consensus:</p><ul><li>Asynchronous: This is a network model that assumes that there is no bound on the delay of message delivery or the relative speed of the nodes. In other words, messages can take arbitrarily long to reach their destination, and nodes can operate at different rates. Asynchronous networks are realistic but challenging, as they make it impossible to distinguish between a failed node and a slow node, or between a lost message and a delayed message. As a result, no deterministic fault-tolerant consensus protocol can guarantee progress (termination) in an asynchronous network, as proved by Fischer, Lynch and Paterson.</li><li>Partial synchrony: This is a network model that assumes that there is a bound on the delay of message delivery or the relative speed of the nodes, but this bound is unknown or may change over time. In other words, messages can take a long time to reach their destination, but not infinitely long, and nodes can operate at different rates, but not infinitely different. Partial synchrony networks are more realistic and less challenging than asynchronous networks, as they allow for some degree of coordination and timing among the nodes. As a result, fault-tolerant consensus protocols can be designed to achieve progress (termination) in a partially synchronous network, as demonstrated by Dwork, Lynch and Stockmeyer.</li></ul><h3>Paxos</h3><p>Paxos is a family of protocols for solving consensus in a network of unreliable or fallible processors. Consensus is the process of agreeing on one result among a group of participants. This problem becomes difficult when the participants or their communications may experience failures. Paxos guarantees safety (agreement and validity) in any network model, and liveness (termination) in a partially synchronous network model. Paxos has changed the paradigm of consensus by providing a simple and elegant formalism, and one of the earliest proofs of safety for a fault-tolerant distributed consensus protocol. Paxos also offers a spectrum of trade-offs between the number of processors, number of message rounds, number of messages, and types of failures. Paxos is widely used in various applications, such as state machine replication, distributed databases, and blockchain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x3vWT7TruNBuebPinsC82g.png" /></figure><p>Paxos maintains safety by using a two-phase protocol, where each node can act as a proposer, an acceptor, or a learner. A proposer initiates a proposal with a unique number and a value and sends it to a majority of acceptors. An acceptor can either accept or reject the proposal, depending on whether it has seen a higher-numbered proposal before. A learner can learn the value that has been accepted by a majority of acceptors and decide on that value. Paxos ensures that no two different values can be accepted by a majority of acceptors, by requiring that an acceptor can only accept a proposal if it has not promised to reject any higher-numbered proposals.</p><p>Paxos maintains liveness by using a leader election mechanism, where one node is designated as the leader, and is responsible for proposing values and coordinating the consensus process. The leader can change over time, depending on the network conditions and the availability of the nodes. Paxos ensures that the leader can eventually make progress, by requiring that the leader has the highest proposal number among all the nodes, and that the leader can communicate with a majority of acceptors.</p><h4>So, every SMR PROTOCOL take inspiration PAXOS. It gives the building blocks for consensus protocol while having omission failures in the replication system.</h4><p>Same with the casperFFG which watches LOCK as justified viewpoints and Highest view = Greatest height</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qTXnCPFF8iOYm5F2e-VS6A.png" /></figure><p>The three phases are:</p><ul><li>Pre-prepare: The leader (or primary) node initiates a proposal with a unique number and a value and sends it to a majority of follower (or backup) nodes. The follower nodes check the validity of the proposal and send back an acknowledgment message.</li><li>Prepare: The leader node collects the acknowledgment messages from the follower nodes and sends a commit message to a majority of follower nodes. The follower nodes check the consistency of the commit message and send back a confirmation message.</li><li>Commit: The leader node collects the confirmation messages from the follower nodes and decides on the value. The follower nodes also decide on the value if they receive confirmation messages from a majority of other follower nodes.</li></ul><p>This protocol ensures that no two different values can be accepted by a majority of nodes, by requiring that a node can only accept a proposal if it has not promised to reject any higher-numbered proposals. This prevents the possibility of a fork, which is a situation where different nodes have different views of the state of the system. The protocol also ensures that the nodes can detect and tolerate faulty or malicious nodes, by using a fork accountability mechanism. This mechanism allows the nodes to identify and punish the nodes that have violated the protocol rules, by sending conflicting votes for different values. This deters the nodes from behaving dishonestly and increases the security and resilience of the system.</p><h3>THE BASE SETUP FOR HOTSTUFF</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KCKgixUN4OpnOMZnxlPjdg.png" /></figure><p>HotStuff works by using a leader-based protocol, where one node is designated as the leader, and is responsible for proposing and coordinating the consensus process. The leader can change over time, depending on the network conditions and the availability of the nodes. HotStuff uses a three-phase protocol, where each node can act as a proposer, an acceptor, or a learner.</p><p>HotStuff ensures that no two different values can be accepted by a majority of acceptor nodes, by requiring that an acceptor node can only accept a proposal if it has not promised to reject any higher-numbered proposals. This prevents the possibility of a fork, which is a situation where different nodes have different views of the state of the system. HotStuff also ensures that the nodes can detect and tolerate faulty or malicious nodes, by using a fork accountability mechanism. This mechanism allows the nodes to identify and punish the nodes that have violated the protocol rules, by sending conflicting votes for different values.</p><p>HotStuff is a breakthrough in Byzantine fault tolerant consensus, as it enjoys both responsiveness and linear view change. Responsiveness means that the protocol can reach consensus at the pace of the actual network delay, rather than the maximum network delay. Linear view change means that the protocol can switch to a new leader with a communication complexity that is linear in the number of nodes, rather than quadratic. HotStuff is also built around a novel framework that forms a bridge between classical BFT foundations and blockchains. It allows the expression of other known protocols, such as PBFT, Tendermint, Casper, etc., in a common framework.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c2ZcQR3C7Z3T_QLEA2tWfA.png" /></figure><h4>How we make any partial asynchronous agreement protocol to run in asynchrony ? Here is the example how we can run it whether it is pbft , tendermint , hotsuff or casper by this technique we can run a asynchronous protocol …..</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xPUIkZEDo_wz_6op7zfBpA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fxs6H9Kjzc1Nfqx52aTYZw.png" /></figure><p>A single leader speaks once based consensus protocol is a type of protocol that aims to achieve Byzantine fault tolerance in a distributed system, where some nodes may fail or behave maliciously. In this protocol, one node is designated as the leader, and is responsible for proposing and coordinating the consensus process. The leader can only propose and certify a single value, and then it rotates to another node. The other nodes can either accept or reject the leader’s proposal, depending on whether it is valid and consistent with the previous proposals.</p><p>The advantage of running a single leader speaks once based consensus protocol is that it can minimize the fairness concerns and the influence of adaptive adversaries, who can control the network and manipulate the consensus process. By limiting the leader’s power and frequency, the protocol can prevent the leader from dominating or censoring the proposals, or from front-running or delaying the messages. The protocol can also increase the security and the resilience of the system, by detecting and punishing the nodes that violate the protocol rules, such as sending conflicting or corrupted messages.</p><h3>PART II — DAG FLYWHEEL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gdPdF-2rDzU_FonQ36qYLw.png" /></figure><p>A DAG is a type of graph that has directed edges and no cycles. It can be used to model various problems and applications in distributed systems, such as consensus protocols. Consensus protocols are algorithms that allow a set of processes to agree on a common value or state, despite the presence of faults or delays in the network.</p><p>Some consensus protocols use a DAG structure to improve the throughput and scalability of the system, by allowing parallel processing and validation of transactions or messages. However, using a DAG also introduces some challenges, such as how to order the transactions or messages in a consistent and deterministic way, and how to handle conflicting or conflicting transactions or messages.</p><h4>These are some advances made in Reliable broadcast based DAGs</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wTy1KWc22WccBtQc6wQarQ.png" /></figure><p>Hashgraph is a distributed ledger technology that has been described as an alternative to blockchains. It uses a “gossip about gossip” protocol where the individual nodes on the network “gossip” about transactions to create directed acyclic graphs that time-sequence transactions . Each “gossip” message contains one or more transactions plus a timestamp, a digital signature, and cryptographic hashes of two earlier events. This makes Hashgraph form an asynchronous Byzantine Fault -Tolerant (aBFT) consensus algorithm.</p><p>Virtual voting and zero message embedding are two techniques that Hashgraph uses to achieve fast and secure consensus. Virtual voting is a way for nodes to vote on the validity and order of transactions without sending any additional messages. Instead, each node calculates what other nodes would vote based on the information in the gossip messages and the hashgraph data structure. Zero message embedding is a way for nodes to embed new transactions into the gossip messages without increasing the message size. This is done by using a hash function that combines the transaction data with the message data, and then using the hash as the message identifier.</p><h4>These are some important papers written around Reliable broadcast based DAGs</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J9y6_97ed-NksLZQxaMDcQ.png" /></figure><h3>PART III — LAYER 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ftRn574wnkFPCUld0UTjEg.png" /></figure><h4>This is the roadmap setup bt the ethereum team initially and somewhat you wont find ZK in it . That i have discussed in early blog , how it works and how it impacts the landscape of L2 — <a href="https://weufoundation.medium.com/snark-design-and-their-role-in-rollups-e8062c160f99">https://weufoundation.medium.com/snark-design-and-their-role-in-rollups-e8062c160f99</a></h4><p>Here we going to Discuss the design and Architecture around sharding , Plasma and Rollups in the means of input , order , execution and output.</p><h3>SHARDING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZtC4h4nY7aZrGop8Poqs3Q.png" /></figure><p>Sharding is a technique of dividing a large database into smaller and more manageable parts, called shards, that are distributed across multiple servers or nodes. Sharding can improve the scalability and performance of a database system, as well as reduce the transaction cost and load on each server or node.</p><p>However, sharding also introduces some challenges and problems, such as:</p><ul><li>How to choose a suitable sharding scheme that balances the load and minimizes the cross-shard communication.</li><li>How to ensure the consistency, availability, and fault-tolerance of the sharded database, especially when some shards may fail or become unavailable.</li><li>How to handle complex queries that span multiple shards, such as joins, aggregations, and transactions.</li><li>How to backup and restore the sharded database, as well as migrate and rebalance the shards when the data or the system changes.</li></ul><p>Vertical scaling has some advantages over horizontal scaling, such as simplicity, consistency, and compatibility. However, vertical scaling also has some limitations, such as cost, availability, and scalability.</p><p>Vertical scaling can be more costly than horizontal scaling, as it requires more expensive hardware and software upgrades. Vertical scaling can also reduce the availability of the system, as it may require downtime or service interruption during the upgrade process. Vertical scaling can also reach a physical limit, as there is a finite amount of resources that can be added to a single server or node.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WvV1qiKqEEBh3Wljw8kngA.png" /></figure><p>Vertical scaling with optimistic concurrency control is a technique that allows a database system to increase its performance and capacity by adding more resources to an existing server or node, while avoiding data locking and conflicts.</p><p>Optimistic concurrency control is an approach for updating databases that uses snapshots to make updates instead of traditional locking mechanisms1 It assumes that most transactions do not conflict with each other, and only checks for conflicts at the end of the transaction. If a conflict is detected, the transaction is aborted and restarted .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TWuvr3Ru2zYqkx7EvRDXVQ.png" /></figure><p>Some of the challenges in horizontal scaling are:</p><ul><li>It requires more software and hardware resources, such as load balancers, network switches, and servers, which can increase the cost and complexity of the system.</li><li>It may need application architecture and code changes to support the distributed nature of the data, such as sharding, replication, and synchronization. This can affect the performance and consistency of the system</li><li>It carries a face where every client or shards carry less security due to dissecting into sub systems.</li></ul><h3>Some problems around payment channels</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LTIUMpE6vGdTiseXeWW8Pg.png" /></figure><p>As Data availability is happening on L2 that seems a bit of a problem where you have to come with a proof to the operator and if operator is malicious then it will be bad for the system design. Still more designs can be thought around this….</p><h3>EVOLUTION OF A ROLLUP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OXOV0yZeHJoYbUrC3sFmGw.png" /></figure><p>Now layer 2 blockchains also start doing Data Availability and Provide Consensus so they can decentralized the sequencer nodes ,which bring a paradigm shift in how we see layer 2 as now . Many blockchains like Celestia , Avail , Eigen layer , Anoma , Expresso etc…. are building around these issues .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t5xWJV3g241pIAIYgF9vKQ.png" /></figure><p>The current scenario sits on how L1 and L2 are seeing it from the business perspective and in able to capture this Trust based market.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PQsghkxMQqygPeiQep75ow.png" /></figure><p>Asymmetric trust is a concept that describes the situation where different parties in a system have different levels of trust or assumptions about each other or the system itself. For example, in a blockchain network, each participant can choose who to trust and how much to trust them, based on their own criteria and preferences. This can lead to different views of the system state and the validity of transactions among the participants.</p><p>Asymmetric trust can have some advantages, such as allowing more flexibility and customization for the users, and enabling more efficient and scalable protocols that do not rely on global consensus or synchronization. However, asymmetric trust can also pose some challenges, such as how to ensure the security, consistency, and fairness of the system, and how to handle conflicts or disputes among the participants</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tTDgI0c_Sk-b9Fd5hCdDeg.png" /></figure><p>In layer 1, different participants may have different trust assumptions about the consensus mechanism, the network reliability, or the data availability .</p><p>In layer 2, different participants may have different trust assumptions about the validity proofs, the dispute resolution, or the fraud prevention.</p><p>Asymmetric trust can have both advantages and disadvantages for a blockchain system. On the one hand, asymmetric trust can allow more flexibility and customization for the users, and enable more efficient and scalable protocols that do not rely on global consensus or synchronization. On the other hand, asymmetric trust can also pose challenges for the security, consistency, and fairness of the system, and require mechanisms to handle conflicts or disputes among the participants,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6kfx8YeVzUiiTsKUf6SnA.png" /></figure><p>I hope you enjoyed reading my blog about how trust in blockchain is an important factor that influences the design and performance of different protocols and solutions. I tried to explain how consensus flywheel, DAG flywheel, and layer 2 flywheel are three approaches that leverage asymmetric trust to achieve scalability and efficiency in decentralized systems.</p><p>As a conclusion, I would like to share some of my favourite quotes about trust and blockchain that inspire me and reflect the potential of this technology:</p><ul><li>“We have elected to put our money and faith in a mathematical framework that is free of politics and human error.” ~ Tyler Winklevoss, Founder, Gemini Cryptocurrency Exchange 2</li><li>“The blockchain symbolizes a shift in power from the centres to the edges of the networks.” ~ William Mougayar, Chair, Kin Foundation 3</li><li>“We believe that the next wave of computing innovation will be driven by crypto. We are radically optimistic about crypto’s potential to restore trust and enable new kinds of governance where communities collectively make important decisions about how networks evolve, what behaviours are permitted, and how economic benefits are distributed.” ~ Chris Dixon, Katie Haun, Ali Yahya, Partners, a16z 4</li></ul><p>Thank you for reading my blog and I hope you learned something new and interesting. If you have any questions or feedback, please feel free to leave a comment below. 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8abc3335e5f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SMR | Tendermint ( Partial Synchronous)| PERMISSIONLESS SETTINGS AROUND A CONSENSUS PROTOCOL]]></title>
            <link>https://weufoundation.medium.com/smr-partial-synchronus-tendermint-permissionless-settings-around-a-consensus-protocol-4a8dd604339d?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a8dd604339d</guid>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[permissionless-blockchain]]></category>
            <category><![CDATA[tendermint]]></category>
            <category><![CDATA[consensus-protocol]]></category>
            <category><![CDATA[state-machine-replication]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Sat, 30 Sep 2023 10:40:24 GMT</pubDate>
            <atom:updated>2023-09-30T15:11:35.780Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hQqUL1xluajEapl_JGugcg.png" /></figure><p>Before reading blog, you can go through this blog for introduction and knowing more around byzantine general problem and how it all started -<a href="https://weufoundation.medium.com/consensus-design-around-byzantine-problem-ce75696cd89c">https://weufoundation.medium.com/consensus-design-around-byzantine-problem-ce75696cd89c</a> .</p><p>This blog will take you through these questions are SMR, TENDERMINT AND PERMISSIONLESS SETTINGS</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nw3XBU14R_G5m2JAwwD5Fg.png" /></figure><p>IN THE LAST BLOG WE HD DISCUSSED AROUND BB AND BA (with pki and without pki). Today, in this blog we talked about State Machine Replication (most of the blockchain uses SMR protocol)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*arZSJco1178bkG16lljK6A.png" /><figcaption>Let&#39;s start with SMR.</figcaption></figure><h3>STATE MACHINE REPLICATION</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ivj4TnthAgunxphg8VHRDQ.png" /></figure><p>A technique where each node maintains a copy of a state machine, and they need to execute the same sequence of commands on their state machines in order to keep them consistent. For example, a bank system may use SMR to ensure that all the branches have the same balance for each account.</p><p>Let&#39;s take a poker game example with Alice, Bob, Carol and Dave.</p><p>One possible creative example around state machine replication technique in blockchain is a story about a group of friends who want to play a game of poker online. Here is how it goes:</p><p>Alice, Bob, Carol, and Dave are four friends who love to play poker. They decide to use a blockchain-based platform to play a game of poker online, without trusting any third-party service. They each download a poker app that implements state machine replication (SMR) to ensure that the game is fair and consistent, even if some of them are dishonest or offline.</p><h4>The app works as follows:</h4><ul><li>The app creates a set of four nodes, one for each player, and assigns them unique identifiers and public keys. Each node represents a state machine that can process inputs (such as bets, cards, and actions) and produce outputs (such as messages, transactions, and outcomes).</li><li>The app also creates a smart contract that defines the rules of the game, such as the initial pot, the betting rounds, the card dealing, and the winning conditions. The smart contract is a deterministic function that takes the current state and input of the game and produces the next state and output of the game.</li><li>The app uses a consensus protocol to coordinate the nodes and ensure that they agree on the same state and output of the game at each step. The consensus protocol works by having each node propose a block that contains one or more inputs from the players, and having the other nodes validate and accept the block if it follows the smart contract. The protocol also handles forks, conflicts, and failures by using a reputation system that rewards honest nodes and penalizes dishonest nodes.</li><li>The app uses cryptography to secure the communication and transactions between the nodes. The app uses digital signatures to verify the identity and authenticity of the inputs from the players and uses encryption to hide the cards from other players until they are revealed.</li></ul><p>The game starts as follows:</p><ul><li>Alice creates a new game on the app and invites Bob, Carol, and Dave to join. She sets the initial pot to 100 tokens and the minimum bet to 10 tokens. She also sets a timeout of 10 seconds for each player to make their move.</li><li>Bob, Carol, and Dave accept the invitation and join the game. They each deposit 100 tokens from their wallets to the smart contract. The app generates a random seed and uses it to shuffle and deal two cards to each player. The app also creates a genesis block that contains the initial state and output of the game and broadcasts it to all nodes.</li><li>Alice is the first player to act. She decides to raise by 20 tokens. She sends her input (raise 20) to her node, which creates a new block that contains her input and signs it with her private key. Her node then broadcasts the block to the other nodes.</li><li>Bob, Carol, and Dave receive Alice’s block and validate it by checking her signature and applying her input to the smart contract. They see that Alice has raised by 20 tokens and that the new state and output of the game are updated accordingly. They accept Alice’s block and append it to their local chains.</li><li>Bob is the next player to act. He decides to fold. He sends his input (fold) to his node, which creates a new block that contains his input and signs it with his private key. His node then broadcasts the block to the other nodes.</li><li>Alice, Carol, and Dave receive Bob’s block and validate it by checking his signature and applying his input to the smart contract. They see that Bob has folded and that the new state and output of the game are updated accordingly. They accept Bob’s block and append it to their local chains.</li></ul><p>The game continues in this manner until one of the following conditions is met:</p><ul><li>One player wins all the tokens in the pot by having the best hand or by making all other players fold.</li><li>All players agree to end the game by sending a special input (end) to their nodes.</li><li>A timeout or a failure occurs on one or more nodes.</li></ul><p>In any case, the app uses the final state and output of the game to determine the outcome and distribute the tokens accordingly. The app also updates the reputation scores of each node based on their behaviour during the game.</p><h4>A bit around how they are different.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9GaMPoFrXHsTxFp0r8kpWg.png" /></figure><p>State Machine Replication (SMR) is a method for implementing a fault-tolerant service by replicating servers and coordinating client interactions with server replicas. SMR is significantly more challenging than Byzantine Agreement because it involves parties agreeing on not just a single value, but a sequence of values or operations. This means that in SMR, the participants (clients) and requests can change over time, and the protocol needs to handle these changes to ensure consistency across all replicas.</p><p>BA or BB focuses on achieving consensus on a single value among processors in the presence of faults, SMR deals with maintaining consistency across replicated servers in a changing environment with varying clients and requests.</p><h3>THE SETUP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eFLmzWyWX1hUBPT618UXaA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5k_P59e1PGGHkq-ptCxUiQ.png" /></figure><p>A client is an entity that interacts with the service by sending requests and receiving responses. A client can be a human user, an application, or another service that runs on top of the consensus protocol.</p><h3>THE REQUIREMENTS</h3><p>Consistency and liveness are two important properties of distributed systems. Consistency means that the system behaves in a predictable and correct way, and liveness means that the system makes progress and responds to requests.</p><p>The requirement setting with consistency and liveness depends on the specific goals and needs of the system. For example, some systems may require strong consistency, which means that all nodes see the same data at the same time, but this may sacrifice availability or partition tolerance. Other systems may prefer eventual consistency, which means that nodes may see different versions of data for a while, but they will eventually converge to the same state, but this may compromise correctness or safety.</p><p>Some examples of consistency models in distributed systems are:</p><ul><li>Strong consistency: Reads always return the most recent write, and writes are visible to all nodes immediately.</li><li>Sequential consistency: Reads and writes appear to happen in some sequential order, and operations of each node appear in this order as specified by its program.</li><li>Causal consistency: Reads and writes that are causally related (i.e., one depends on another) appear to happen in the same order for all nodes.</li><li>Eventual consistency: Reads and writes may return different values for a while, but they will eventually converge to the same value.</li></ul><p>Some examples of liveness properties in distributed systems are:</p><ul><li>Availability: Every request receives a response from a non-failing node.</li><li>Progress: Every non-failing node eventually executes its operations.</li><li>Termination: Every operation eventually completes.</li><li>Fairness: Every node has a fair chance to execute its operations.</li></ul><h4>BUT HERE WE ARE GOING TO DISCUSS AROUND SMR</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4n9ITDXCRhlzoKEx1_OxIg.png" /></figure><ul><li>Consistency means that all nodes in the network agree on the same state of the blockchain, which is a sequence of blocks that contain transactions. Consistency ensures the validity and integrity of the data.</li><li>Liveness means that the network can process new transactions and add new blocks to the blockchain. Liveness ensures the availability and responsiveness of the service.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YUnANFhmJyzXuBMNZs2BIw.png" /></figure><ul><li>The <strong>confirmed set</strong> of a processor as the set of transactions that have been signed by a majority of non-faulty processors. A transaction is signed by a processor when it receives a message from the client that contains the transaction and a digital signature.</li><li>The protocol satisfies the SMR properties under the assumption that at least one non-faulty processor receives a signed transaction from each client. The proof is based on showing that the confirmed sets of non-faulty processors are always <strong>consistent</strong> (they contain the same transactions) and <strong>progressive</strong> (they grow over time).</li><li>It allows <strong>lazy clients</strong> to participate in the system without sending messages to all processors. A lazy client is a client that only sends transactions to a subset of processors, instead of broadcasting them to everyone. Though even bitcoin allows this property where the clients can go out of the consensus participation and come back and take part in consensus with f+1 conf. from distinct processors, even if the transactions are confirmed by non-faulty processors. Because the dishonest guy can act malicious in the network but if i carry f+1 confirmations we really don&#39;t have to care about even the client went offline.</li></ul><h4>A consequence for lazy client condition is SMR cannot be solved if f ≥ n/2.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JYyNfQKk22qsj2xIDMU5fw.png" /></figure><p>The Dolev-Strong protocol is a consensus protocol that solves the state machine replication problem under the synchronous model assumption. . The synchronous model assumption is the assumption that the communication network has reliable message delivery and bounded message delays.</p><p>The Dolev-Strong protocol works as follows: There is a designated sender node that has a private input, and a set of receiver nodes that need to agree on the sender’s input. The sender node broadcasts its input along with a digital signature to all other nodes. Each node that receives a message from the sender or another node forwards it to all other nodes, unless it has already forwarded a message with the same content. Each node maintains a set of messages that it has received, and decides on the output based on the following rules:</p><p>- If there are more than f messages with the same content and valid signatures from different nodes, where f is the maximum number of faulty nodes, then output that content.<br>- If there are more than f messages with different contents and valid signatures from different nodes, then output ⊥ (meaning no agreement).<br>- If neither of the above conditions holds after N rounds, where N is the total number of nodes, then output ⊥.</p><p>The Dolev-Strong protocol guarantees that all honest nodes will output the same value, and that value will be equal to the sender’s input if the sender is honest. This means that the protocol satisfies the properties of agreement and validity, which are the desired properties of a consensus protocol. The protocol is also very fault-tolerant, as it can tolerate up to N-1 faulty nodes out of N total nodes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gY3FweOlDVDQXt0F-EbB2Q.png" /></figure><p>So it proves that using Dolev- Strong protocol it is quite simple to implement SMR.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T81lgPAjY9dMrUa90TMlkQ.png" /></figure><h4>LETS SOLVE A BIT AROUND BYZANTINE BROADCAST USING THE SAME SOLUTION AS SMR</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NZcpBrKLtt2Dbbffawt03g.png" /></figure><h3>PARTIALLY SYNCHRONOUS SETTINGS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KlDSQt8QoBeDxnusUEfqDQ.png" /></figure><p>Partial synchronous settings are a way of modeling the communication network of a distributed system. They are based on the idea that the network is usually reliable and fast, but sometimes it can experience delays or failures due to unpredictable events.</p><p>As they have to maintain the consistency of the network when network conditions will not be good, but as soon as network conditions becomes good liveness comes in place because when network conditions are not good, they were not receiving any messages, so liveness was not maintained.</p><h4>So how we are going to implement it? Well here is the solution-</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OTve_5RevSK9wn8ky6Bqmw.png" /></figure><p>There are two parameters that describe the network behavior: a known finite time range ⊿ and an unknown event called GST (global stabilization time). Before GST, the network can behave arbitrarily, meaning that messages can be lost, delayed, reordered, or duplicated.</p><p>After GST, the network becomes synchronous, meaning that messages are delivered within ⊿ time units. However, the nodes in the system do not know when GST occurs or if it has occurred at all.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R3ltMV7QkqJlxlwmdRr1nA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wbKjxhlVD4qYrzzH9vyMuw.png" /></figure><h4>In this case, processors also don&#39;t know the upper bound delta, so protocols can function for any finite bound without knowing its value.</h4><h4>The thing is to figure for which n and f model the protocol works out.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p1G15jyqWdb9-cm5eWq_Pw.png" /></figure><ul><li>The unknown Δ model and the GST model. These models are equivalent, meaning that they capture the same network behavior and assumptions. Here we discuss also that how to convert a protocol that works under one model to work under the other model.</li><li>The <strong>unknown Δ model</strong> is a partial synchronous setting where Δ is unknown to the nodes. This means that the nodes do not know how long it takes for a message to be delivered after GST. The unknown Δ model is useful for designing protocols that do not depend on timing assumptions.</li><li>The <strong>GST model</strong> is a partial synchronous setting where Δ is known to the nodes. This means that the nodes know how long it takes for a message to be delivered after GST. The GST model is useful for analysing protocols that use timing assumptions.</li></ul><h4>How to convert a protocol that works under the unknown Δ model to work under the GST model.</h4><ul><li>The idea is to give each node the ability to turn Δ into 1 by increasing the intervals between the times at which they execute their instructions. For example, if a node executes an instruction at time t under the unknown Δ model, it will execute it at time 2t under the GST model with Δ = 1. This way, even if GST is larger than Δ (which means that messages are delivered faster than expected), the nodes will still execute their instructions in sync with each other.</li></ul><h4>How to convert a protocol that works under the GST model to work under the unknown Δ model.</h4><ul><li>The idea is to use an algorithm called Clock Synchronization, which allows each node to estimate an upper bound on Δ based on their local clocks and message timestamps. This way, even if Δ is unknown to the nodes (which means that messages are delivered slower than expected), they can still use timing assumptions based on their estimates.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5gSGporTwhIr4BL6SrVEwQ.png" /></figure><p>The main thing in BB is like if the broadcaster is faulty, which is f≥1 it not possible and even we have a working protocol it is not possible, due to the contradiction we discussed.</p><h3>BA and SMR in partially synchronous settings</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*meX3A0DRjePrJf7I5kGiWQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eCgvK4O8mG6wJXu3nmilUA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bSYnEGEUXCoWYY6lm38iLw.png" /></figure><p>As we can observe, in the three processors system in the partial synchronous setting is not possible if f≥ n/3.</p><p><strong>Well, if we can solve SMR in the partially synchronous setting we can solve BA too with that. So, we are directly ging to talk around SMR here -</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ANzHiBSTTfHzkuxmOwQHQ.png" /></figure><h3>BA and SMR in partially synchronous settings with PKI</h3><h3>A.K.A Solving TENDERMINT</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lPoShSljuUpd69Qa3I10nQ.png" /></figure><p>An incompatible block in Tendermint is a block that violates the consensus protocol rules, such as having an invalid signature, a wrong hash, or a conflicting previous block. An incompatible block can cause a fork, which is a situation where different validators have different views of the blockchain history. A fork can only happen if at least 1/3 of the validators are faulty or malicious and sign conflicting blocks. Tendermint uses a two-stage voting mechanism to prevent forks and ensure safety and liveness of the protocol.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a5JN2SgTXaEaIQo70HaICw.png" /></figure><ul><li>Tendermint consists of two main components: a <strong>consensus algorithm</strong> and an <strong>application interface</strong>. The consensus algorithm is responsible for coordinating the nodes and reaching agreement on the transactions. The application interface is responsible for validating and executing the transactions and updating the state.</li><li>The consensus algorithm is based on a variant of <strong>Practical Byzantine Fault Tolerance (PBFT)</strong>, which is a classical protocol that can tolerate up to one-third of faulty nodes. The algorithm uses a <strong>leader-based</strong> approach, where one node is selected as the <strong>proposer</strong> for each round, and proposes a block of transactions to be committed. The other nodes are called <strong>validators</strong>, and they vote on the proposed block using a <strong>two-phase voting</strong> mechanism.</li><li>The application interface is based on the <strong>ABCI (Application Blockchain Interface)</strong>, which is a generic interface that allows any application to run on top of Tendermint. The ABCI defines three types of messages that are exchanged between the consensus algorithm and the application: <strong>CheckTx</strong>, <strong>DeliverTx</strong>, and <strong>Commit</strong>. CheckTx is used to check the validity and priority of a transaction before proposing it. DeliverTx is used to execute a transaction and update the state after it is committed. Commit is used to compute and return a cryptographic hash of the state after each block.</li><li>Tendermint has several advantages over other consensus protocols, such as high performance, simplicity, and flexibility. Tendermint can achieve high performance because it only requires two rounds of communication to commit a block, and it can handle thousands of transactions per second. Tendermint is simple because it only relies on a few assumptions and parameters, and it has a clear separation of concerns between consensus and application logic. Tendermint is flexible because it can support any application that can be modeled as a state machine, and it can be easily integrated with other protocols and platforms.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W5_-soF2Pwtc91pgEApS_A.png" /></figure><p>It&#39;s going to simple in terms where if someone is providing the block, and if he doesn&#39;t know the predecessor chain rather than we are going to see block they are going to see the predecessor chain. And after that they are going to consider the block.</p><p>Quorum certificates are a way of proving that a majority of nodes have voted for a certain value or block in a round of the consensus algorithm. The consensus algorithm is based on a variant of Practical Byzantine Fault Tolerance (PBFT), which is a classical protocol that can tolerate up to one-third of faulty nodes. The algorithm uses a leader-based approach, where one node is selected as the proposer for each round and proposes a block of transactions to be committed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HtrmqtwM7vGluCX07tQdwQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OtQNJufrAyBP-xaToMDxDg.png" /></figure><p>By this way, it doesn&#39;t work though, but if we include two rounds of communication and f+1 proof this is going to work out.</p><h4>Two stages of voting.</h4><p>What happens if we consider two stages of voting on the block instead? If they see a QC on the block B produced in stage 1 (say) of round r, proposers then produce a stage 2 vote, and it is a QC in stage 2 that means confirmation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R3SEg7FByKqgs63W_f--mQ.png" /></figure><p>Does this work? The problem with the previous protocol was that a block might be confirmed, but non-faulty processes might not see the relevant QC.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4fz9WMvC8AIIpUfG0zx5tQ.png" /></figure><p>So, if we have two stages of voting, if we consider blocks confirmed when they see a Stage 2 QC but already have processors ‘lock’ on a block when they see a Stage 1 QC, then we’ll satisfy consistency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KC9PWKbR-UPi2HqC4J4gTg.png" /></figure><h4>Summary so far:</h4><p>Have two stages of voting in each round.</p><p>Have processors lock on a block when they see a Stage 1 QC.</p><p>Release the lock when they see an incompatible block with a higher QC.</p><p>Consider a block confirmed when it gets a Stage 2 QC.</p><h4>…then we’ll satisfy consistency. It’ll also be easy to prove liveness.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mY58H3g9V5pqr7cdGZQurA.png" /></figure><p>Its going to be the same , with just release in the round 1 , if the processors see that there are more QC locked</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QSdLm-4vX3HMa2cEDhBs4A.png" /></figure><p>A QC block is considered to be valid and can be extended by the leader of the round. The protocol consists of three steps:</p><ul><li><strong>Time t = 3rA</strong>: The leader of the round extends the highest QC block they have and broadcasts it to other nodes. They also set a timer for Δ time units.</li><li><strong>Time t + Δ</strong>: The leader checks whether they have received a higher QC block from another node. If so, they abandon their own block and extend the higher one. They broadcast the new block and reset the timer for another Δ time units.</li><li><strong>Time t + 2Δ</strong>: If the leader’s block receives enough votes from other nodes to form a Stage 2 QC, the block is confirmed and added to the chain. Otherwise, the leader waits for another Δ time units and repeats the process.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*szExJZh_i-Ze8XVgZcfcng.png" /></figure><h3>Casper FFG ( Ethereum)</h3><p>Casper FFG is a consensus protocol for the realization of proof-of-stake (PoS) on Ethereum. It is based on the idea of a finality gadget, which is a mechanism that can finalize blocks on top of an existing proof-of-work (PoW) chain. Casper FFG uses a hybrid PoW/PoS model, where PoW is used for block proposal and PoS is used for block finalization. Casper FFG aims to achieve the following goals:</p><ul><li>Security: Casper FFG ensures that finalized blocks are secure and irreversible, even in the presence of network delays or malicious nodes. It also introduces a slashing mechanism that penalizes nodes for violating the protocol rules or trying to revert finalized blocks.</li><li>Scalability: Casper FFG reduces the need for PoW, which consumes a lot of energy and resources. It also enables faster confirmation times and higher throughput, as finalized blocks do not need to wait for more PoW confirmations.</li><li>Decentralization: Casper FFG allows anyone to participate in the consensus process by staking Ether, the native currency of Ethereum. It also reduces the risk of centralization by making PoW less dominant and rewarding honest nodes for their contributions.</li></ul><p>Casper FFG works as follows:</p><ul><li>The underlying PoW chain produces blocks at regular intervals, called epochs. Each epoch consists of 50 blocks, and the first block of each epoch is called a checkpoint. Checkpoints are the only blocks that can be finalized by Casper FFG.</li><li>The nodes that participate in Casper FFG are called validators. Validators have to deposit a minimum amount of Ether into a smart contract, called the validator deposit contract, to join the validator set. Validators can also withdraw their deposits after a certain period of time, called the withdrawal period.</li><li>Validators take turns to propose checkpoints and vote on them. The proposer of a checkpoint is chosen randomly by a function that depends on the epoch number and the validator IDs. The proposer broadcasts their proposed checkpoint to other validators, along with a reference to the previous checkpoint they have seen.</li><li>Validators vote on checkpoints by sending messages that contain their ID, the hash of the checkpoint, the epoch number, and their signature. Validators can vote on multiple checkpoints in different epochs, but they have to follow some rules to avoid conflicting votes. These rules are called the slashing conditions, and they prevent validators from voting on two different checkpoints in the same epoch or voting on a checkpoint that does not reference their previous vote.</li><li>A checkpoint is considered justified if it receives votes from at least two-thirds of the validators in terms of stake. A checkpoint is considered finalized if it is justified and its direct ancestor is also justified. A finalized checkpoint cannot be reverted by any means, and it confirms all its ancestors as well.</li><li>Validators receive rewards for proposing and voting on checkpoints, and they lose their deposits if they violate the slashing conditions or go offline for too long. The rewards and penalties are calculated by a formula that depends on various factors, such as the total stake, the number of validators, and the finality delay.</li></ul><p>Casper FFG is an overlay that abstracts the block proposing mechanism and is only responsible for consensus. The block proposing mechanism is implemented by the underlying chain, and the block proposal from the underlying chain is called checkpoints. Casper FFG is inspired by PBFT, a classical Byzantine fault tolerant consensus protocol, but it adds some new features and simplifies some rules. Casper FFG also has some similarities with Tendermint, another PoS-based consensus protocol.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x6hxolOdMEClcNzH7X69mQ.png" /></figure><h3>LET&#39;S SUMMARISE EVERYTHING WITH BA , BB AND SMR ( synchronous and partially synchronous with PKI and without PKI)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BUOt9bz_1SSbzMsGtRpXfg.png" /></figure><h4>A BRIEF AROUND BITCOIN (A PERMISSIONLESS CONSENSUS)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hskQWtOnWT3WpYBlvK11Hw.png" /></figure><ul><li>Probabilistic: Bitcoin does not guarantee that all nodes will agree on the same state at all times, but it makes it very unlikely that they will disagree for long. This is because PoW makes it hard for an attacker to create a longer chain than the honest nodes, unless they have more than 50% of the computing power in the network. The probability of disagreement decreases exponentially as more blocks are added to the chain, making it more secure and stable.</li><li>Works in the synchronous setting: Bitcoin assumes that the network is synchronous, meaning that there is a known upper bound on the message delay between nodes. This assumption is necessary for PoW to work, as it ensures that nodes can synchronize their clocks and agree on the difficulty of the puzzle. If the network is asynchronous, PoW might not be able to prevent forks or double-spending attacks.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vYi2M0qHeDmPSjVqslN7Xw.png" /></figure><ul><li>Lazy client’ condition: Bitcoin also assumes that there is a ‘lazy client’ condition, meaning that there is at least one honest node that does not participate in PoW but only validates and follows the longest chain. This node acts as a passive observer and can detect any inconsistency or fraud in the system. If there is no lazy client, an attacker might be able to fool all active nodes into accepting a fake chain.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OBTzHoNx4nOfCC0ExWqKbg.png" /></figure><h4>I hope it helps you to understand how to solve the consensus problem in STATE MACHINE REPLICATION (with PKI AND WITHOUT PKI).</h4><h4>We discussed how tendermint works and a bit of around permissionless protocol like bitcoin too.</h4><p>I hope you enjoyed reading this blog and learned something new about consensus protocols for distributed systems. Consensus protocols are fascinating and important topics that have many applications and implications for the future of computing and society. If you liked this blog, please share it with your friends and colleagues who might be interested in learning more about SMR, BA and BB. You can also leave a comment below with your feedback or questions. Thank you for reading! 😊</p><p>Written by — Fardeen khan. Thanks to — <a href="https://a16zcrypto.com/team/andrew-lewis-pye">Andrew Lewis-Pye</a> for providing valuable lectures out there .</p><p>Connect with me here — ( <a href="https://x.com/thelastknown_?t=RfAJjWStYGwI6y4GCrOfGA&amp;s=09">https://x.com/thelastknown_?t=RfAJjWStYGwI6y4GCrOfGA&amp;s=09</a> )</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a8dd604339d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CONSENSUS DESIGN AROUND BYZANTINE PROBLEM]]></title>
            <link>https://weufoundation.medium.com/consensus-design-around-byzantine-problem-ce75696cd89c?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce75696cd89c</guid>
            <category><![CDATA[research]]></category>
            <category><![CDATA[byzantine-fault-tolerance]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[blockchain-development]]></category>
            <category><![CDATA[consensus-mechanism]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Sat, 16 Sep 2023 01:36:16 GMT</pubDate>
            <atom:updated>2023-09-28T20:57:40.653Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-ONl0AIUkE8QnGYiHPPmA.png" /></figure><p>A fundamental problem in <a href="https://en.wikipedia.org/wiki/Distributed_computing">distributed computing</a> and <a href="https://en.wikipedia.org/wiki/Multi-agent_system">multi-agent systems</a> is to achieve overall system reliability in the presence of a number of faulty processes. This often requires coordinating processes to reach <strong>consensus</strong>, or agree on some data value that is needed during computation. Example applications of consensus include agreeing on what transactions to commit to a database in which order, <a href="https://en.wikipedia.org/wiki/State_machine_replication">state machine replication</a>, and <a href="https://en.wikipedia.org/wiki/Atomic_broadcast">atomic broadcasts</a>. Real-world applications often requiring consensus include <a href="https://en.wikipedia.org/wiki/Cloud_computing">cloud computing</a>, <a href="https://en.wikipedia.org/wiki/Clock_synchronization">clock synchronization</a>, <a href="https://en.wikipedia.org/wiki/PageRank">PageRank</a>, opinion formation, <a href="https://en.wikipedia.org/wiki/Smart_grid">smart power grids</a>, <a href="https://en.wikipedia.org/wiki/State_estimation">state estimation</a>, <a href="https://en.wikipedia.org/wiki/Unmanned_aerial_vehicle">control of UAVs</a> (and multiple robots/agents in general), <a href="https://en.wikipedia.org/wiki/Load_balancing_(computing)">load balancing</a>, <a href="https://en.wikipedia.org/wiki/Blockchain">blockchain</a>, and others.</p><p>There are various algorithms and protocols that try to solve the consensus problem under different assumptions and settings. Some examples are:</p><ul><li>Paxos: A family of protocols that achieve consensus in a partially synchronous network with crash failures and authenticated messages.</li><li>Raft: A protocol that simplifies Paxos by using a leader-based approach and a randomized election mechanism.</li><li>Byzantine Generals: A protocol that achieves consensus in a synchronous network with malicious failures and authenticated messages.</li><li>PBFT: A protocol that achieves consensus in an asynchronous network with malicious failures and authenticated messages.</li><li>Dolev et al.: A protocol that achieves consensus in an asynchronous network with malicious failures and non-authenticated messages.</li></ul><h4>In this session, we will explore majorly through byzantine general problem. Lets go buddies -</h4><h3>Learning is for those who are curious</h3><h3>WHAT IS A PROBLEM A CONSENSUS PROTOCOL TO SOLVE ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YTVSjLGnytPZKjkL7VKshg.jpeg" /></figure><p>Formal requirements for a consensus protocol may include:</p><ul><li><em>Agreement</em>: All correct processes must agree on the same value.</li><li><em>Weak validity</em>: For each correct process, its output must be the input of some correct process.</li><li><em>Strong validity</em>: If all correct processes receive the same input value, then they must all output that value.</li><li><em>Termination</em>: All processes must eventually decide on an output value</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mqRP5uQ6Fevw7PY5Rgo9mg.jpeg" /><figcaption>We are going to more slide show</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5BkeZklOwF-8u1sU0ZKjMA.jpeg" /></figure><p>If the number of dishonest parties is greater than or equal to half of the total number of parties. The input and output of each party can be different depending on whether they are honest or dishonest , thus creating a impossible situation for parties to reach a consensus with validity .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U_0i2vBE5ZcQCP9nCUCq_g.jpeg" /></figure><h4>Let&#39;s take a real-world situation where-</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PvpKahtJEYEyq7TbEhS1tw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*03t-KxGQSWrEFdDIAp6VsQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U_0i2vBE5ZcQCP9nCUCq_g.jpeg" /></figure><p>CASE STUDY FOR BYZANTINE BASED NETWORK</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m-Usp71EAFLlcrtc2QboVQ.jpeg" /></figure><p>In blockchain setting you can consider, processor as a validator node.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DrOd6cQooAGJKmC9fBa3Ew.jpeg" /></figure><p>The framework consists of the following elements:</p><ul><li>A network of <strong>n</strong> processors, each with a unique identifier, that can communicate with each other through <strong>reliable</strong> and <strong>authenticated</strong> channels.</li><li>A set of possible <strong>messages</strong> that each processor can send and receive, including a special message called <strong>NIL</strong> that represents no message.</li><li>A set of possible <strong>inputs</strong> and <strong>outputs</strong> for each processor, which are subsets of the message set.</li><li>A set of <strong>instructions</strong> for each processor, which specify how to behave in each round of communication. The instructions depend on the processor’s input, the messages received in previous rounds, and a random coin toss. The instructions also determine the processor’s output at the end of the protocol.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SJDoteTPZrgUvEYj-0eJ8Q.jpeg" /></figure><p>Public key infrastructure, or PKI, is a system that enables the secure exchange of information over the internet using public-key cryptography. PKI consists of several components, such as:</p><ul><li><strong>Public and private keys</strong>: These are pairs of mathematical values that can be used to encrypt and decrypt data. The public key can be shared with anyone, while the private key must be kept secret by its owner.</li><li><strong>Digital certificates</strong>: These are electronic documents that bind a public key to the identity and attributes of its owner. They are issued and signed by a trusted authority called a certificate authority (CA).</li><li><strong>Certificate authorities</strong>: These are entities that verify the identity and attributes of the certificate applicants and issue digital certificates to them. They also maintain a database of valid, revoked, and expired certificates.</li><li><strong>Registration authorities</strong>: These are entities that assist the CA in validating the certificate applicants and performing other administrative tasks.</li><li><strong>Certificate management system</strong>: This is a software system that helps manage the life cycle of the certificates, such as creation, distribution, renewal, revocation, and storage.</li></ul><p>PKI also helps prevent man-in-the-middle attacks, where an attacker intercepts and modifies the messages between two parties.</p><p>Here we are going to talk about byzantine framework with PKI and without PKI and how a consensus protocols behaves with and without it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lTIqMO8Pt7eSnqRDdXNo1A.jpeg" /></figure><p>A synchronous network assumes that there is a known upper bound on the delay of message delivery, and that all nodes have synchronized clocks.</p><p>Synchronous networks are easier to analyze and design consensus protocols for, because they can guarantee that honest nodes will receive messages within a certain time frame, and that they can agree on a common view of the network state. However, synchronous networks are also unrealistic and vulnerable to denial-of-service attacks, because an adversary can delay messages or disrupt the network synchronization.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qGY_XzITVA1w3kgZnJWzmw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_74bLyFheSVkK1aMjDIx8Q.jpeg" /></figure><p>Here we are going to address these problems which are listed below -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tV-XgrvMBbY5dVq4k9pZww.jpeg" /></figure><p>So to address these issues will start with synchronous settings</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_KVuHfyjTHnTvuI931nKZw.jpeg" /></figure><p>We already has discussed when the no. of faulty processors are f = or &gt; then n/2 . The consensus protocol is not possible to implemented .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oeVIriVBCD20c__N-wQX-A.jpeg" /></figure><p>A variant of byzantine agreement problem later turns out to be byzantine broadcast problem. Check what it is -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KgVDUNP8thMqvSTFIZA3sw.jpeg" /></figure><h4>Relationship between both</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Lx1ClQLZixG7Yyy5NZ-NA.jpeg" /></figure><p>If f &lt; n/2 , then two problems get evaporated for BA and BB systems</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Clf8DdcJ095-iENS04BDuA.jpeg" /></figure><h3>Different consensus protocols and their designs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*B1uqJevxdzlO5U1hUEpZ_Q.png" /><figcaption>We are mosly going to talk around synchronous settings with PKI and without PKI</figcaption></figure><h3>Byzantine agreement and Byzantine Broadcast with PKI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c1kvhx7LShr3sUBN5QREuA.jpeg" /></figure><ul><li>Here we state as follows-</li><li>A <strong>protocol</strong> that solves the Byzantine Broadcast problem for any number of faulty processors, as long as the sender is honest. The protocol uses <strong>digital signatures</strong> and <strong>threshold encryption</strong> to ensure that the receivers agree on the sender’s input.</li><li>We can also solve <strong>Byzantine Agreement</strong> when working in the synchronous setting with PKI if <strong>f &lt; n/2</strong>, where f is the number of faulty processors and n is the total number of processors. Byzantine Agreement is a more general problem where each processor has an input and they must output a common value that depends on their inputs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-oxCPBw6Jh3TirSmKFsbxA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*94Ml4KXjM1ZUFudFw6kUXg.jpeg" /></figure><h4>The solution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fEVQc2p2pkvWFDYj7FoWoA.jpeg" /></figure><h4>CASE 1</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DuuModKDMA190W3qksO80Q.jpeg" /></figure><h4>CASE 2</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iS03p-cSPyceVa8iwPdiEg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5gGdBWwizF_-K_QgPIxADg.jpeg" /></figure><p>IN A MORE FORMAL SETTINGS, LETS DISCUSS</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wZvmupoV1Nf6yRntcEjEA.jpeg" /></figure><p>The goal of the protocol is to ensure that all honest receivers output the same value as the sender’s input, regardless of how many faulty processors there are, as long as the sender is honest. The protocol also ensures that if all honest processors have the same input, this must be their output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cYbbAx-IjuU5ruwV36i0iw.jpeg" /></figure><h3>BYZANTINE AGREEMENT AND BROADCAST WITHOUT PKI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QKG-867wofMdUypxQQpXkw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i0fawZoqIZiYP9KWD0aadQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u3oeMt_98OLBZ6Y6xsQgbg.jpeg" /></figure><h4>Lets take a case study and discuss around multidimensional byzantine agreement</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*erWVxZiGkhoXKOLlEIDbNQ.jpeg" /></figure><p>Of course, this is not a configuration in which the protocol was intended to operate, but the way in which it behaves here will allow us to deduce things about how the protocol behaves in valid executions.</p><h4>What we can deduce about the outputs of the processors in the setup?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xfBz8RtN9soGnC4Ht5-cXw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tPO9tyO2RvykgQFZ1pzptw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unC_kaN9tuzYivHcyytpOw.jpeg" /></figure><ul><li>In this case , each player has a vector of values instead of a single value, and the agreement must be reached on each dimension separately.</li><li>We can achieve multidimensional Byzantine agreement in O(n²) rounds, where n is the number of players, and tolerates up to t &lt; n/3 Byzantine faults.</li><li>The protocol for n = 3 and f = 1 is depicted in the figure, where each player has a value of either A or B, and one of them is faulty and can simulate other values.</li><li>The faulty player can simulate two different values for the other two players, as shown by the lines connecting the rectangles.</li><li>The contradiction is that the two non-faulty players, 0 and 1, must output different values (A and B) according to the protocol, but they cannot distinguish the figure from another one where they have the same value. This violates the agreement requirement of BA, which states that all non-faulty players must output the same value.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v1tp6_rdRz6ks3ZBpXAjsA.jpeg" /></figure><p>The contradiction is that the two non-faulty players must output the same value according to the agreement requirement, but they cannot tell which value is correct because they see different values from the faulty player.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oU2k-OY2Av_McJOhsa68eA.jpeg" /></figure><h4>There is always a remedy to a problem . Here it is -</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qWbXUNJ9vEeftDnSy4oYMA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X39VAy3AH0gK1cdCFTs6lg.jpeg" /></figure><h4>So far we have discussed about -</h4><h4>Theorem- Consider the synchronous setting with PKI given. There exists a protocol that solves the Byzantine Broadcast problem for any number of faulty processors.</h4><h4>Theorem- Consider the synchronous setting without PKI. No protocol can solve BA or BB when f ≥ n/3.</h4><h3>PHASE KING PROTOCOL AND ITS SUB PROTOCOL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qNv02Umhdj7D2l98O3AXjg.jpeg" /></figure><h3>GRADECAST</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eUMr68HnGFSw0xnYjaSmzQ.jpeg" /></figure><p>Gradecast works by using a combination of two subprotocols: echo and ready. The echo protocol allows a sender to send a message to a group of receivers, and the receivers to echo back the message to each other. The ready protocol allows the receivers to indicate that they have received enough echoes to output a message or ⊥. The gradecast protocol consists of three steps:</p><ul><li>Step 1: The sender sends a message to all receivers, and the receivers echo back the message to each other. If a receiver receives more than 2n/3 echoes of the same message, it sends a ready message with that message to all receivers.</li><li>Step 2: If a receiver receives more than 2n/3 ready messages with the same message, it outputs that message. Otherwise, it outputs ⊥.</li><li>Step 3: If a receiver outputs ⊥ in step 2, it sends a ready message with ⊥ to all receivers. If a receiver receives more than 2n/3 ready messages with ⊥, it outputs ⊥. Otherwise, it outputs the same message as in phase 2.</li></ul><p>The gradecast protocol ensures that if the sender is honest, then all honest receivers output the same message as the sender. Moreover, if some honest receivers output a message, then all honest receivers&#39; output either that message or ⊥. This property is called gradualness, and it allows the receivers to detect if the sender is faulty or not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_bfnv-kOmcjHctnL6PgGew.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U0MZ0xsZpVbbH4Xm3tya0A.jpeg" /></figure><p>The protocol guarantees that:</p><ul><li>If any non-faulty processor outputs a value with grade 2, then all non-faulty processors will send the same value in the second step.</li><li>If any non-faulty processor outputs a value with grade 1, then all non-faulty processors will output the same value with grade 0 or 1.</li></ul><p>Where has this got us? So far, we have a simple protocol which, if all non-faulty processors start with the same input, produces a situation in which they all know that was the case. What we haven’t achieved yet is any method for tie-breaking. If the processors start with a mix of inputs, how to we get them to agree on one value?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*evsEfgiQA42BQK5cHl0dRA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kkd_WD-Z1MqvqbwOLxB06A.jpeg" /><figcaption>Instruction followed by the processor</figcaption></figure><p>Proof of validity and agreement for gradecast. We first prove the validity property of gradecast. In each round, the grade will be 2, meaning that the leader’s value will be ignored. By the knowledge of agreement property, all non-faulty processors will either switch to the leader’s value or already have that value with grade 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oXc6mEGYyUpjfX6St3t4kQ.jpeg" /></figure><ul><li>Thank you for reading this blog. I would love to hear your thoughts and feedback on it.</li><li>This blog was a result of my curiosity and passion for learning about consensus design around the Byzantine problem. I hope it sparked your interest and inspired you to learn more about this fascinating topic. If you have any questions or want to discuss more, please feel free to contact me or join weu foundation community here — <a href="https://linktr.ee/weufoundationsocial">https://linktr.ee/weufoundationsocial</a></li><li>You can connect with me here — <a href="https://twitter.com/thelastknown_?t=1ET8xtA7-fNd9rqiBJAoQw&amp;s=09">https://twitter.com/thelastknown_?t=1ET8xtA7-fNd9rqiBJAoQw&amp;s=09</a></li><li>Please leave a comment below and let me know what you think.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce75696cd89c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SNARKs  DESIGN AND THEIR ROLE IN ROLLUPS(HOW TRANSACTIONS ARE SCALED ON ETHEREUM 100X)]]></title>
            <link>https://weufoundation.medium.com/snark-design-and-their-role-in-rollups-e8062c160f99?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8062c160f99</guid>
            <category><![CDATA[snark]]></category>
            <category><![CDATA[ethereum-blockchain]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Thu, 20 Jul 2023 09:16:32 GMT</pubDate>
            <atom:updated>2023-12-30T07:48:03.948Z</atom:updated>
            <content:encoded><![CDATA[<h3>SNARK DESIGN AND THEIR ROLE IN ROLLUPS(HOW YOU CAN BUILD A SETUP TO SCALE TX.ON ETHEREUM &amp; BUILD PRIVACY PRESERVING APPLICATIONS)</h3><p>Written by — Fardeen khan ( <a href="https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app">https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app</a> )</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aTZZqIhWcv-uguVZ7MVOAg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6mqcayuPxlooN4gmE2VuBw.jpeg" /><figcaption>something very short,do not interact and even tell the prover to proof his knowledge</figcaption></figure><p><a href="https://consensys.net/blog/developers/introduction-to-zk-snarks/">A snark is a type of zero-knowledge proof, which is a cryptographic technique that allows one to prove that a statement is true without revealing any information beyond the validity of the statement</a>. For example, one can prove that they know a password without revealing the password itself.</p><p>A snark stands for Succinct Non-interactive ARgument of Knowledge. This means that a snark is a proof that is:</p><ul><li>Succinct: The size of the proof is much smaller than the size of the witness, which is the secret information that proves the statement.</li><li>Non-interactive: The proof can be verified without any interaction or communication between the prover and the verifier.</li><li>Argument of Knowledge: The proof convinces a computationally bounded verifier that the prover knows a witness that satisfies the statement.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bw4gALoMvrice3kbspi5MQ.jpeg" /><figcaption>our dude plan for conversation today</figcaption></figure><h3><strong>HOW SNARKs ARE DESIGNED ?</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EvN92W987GJbwZ7LXGIqVw.jpeg" /><figcaption>General purpose snark</figcaption></figure><p>The front end of snarks is the part of the system that allows users to write programs or statements that can be compiled into snark circuits. <a href="https://ethereum.stackexchange.com/questions/103195/zk-snarks-high-level-language-options">A snark circuit is a representation of a computation that can be verified using a snark proof, which is a short and non-interactive proof that the computation was done correctly without revealing any details about it</a>.</p><p>The front end of snarks interacts with high level languages by providing tools and features that enable users to express their programs or statements in a more natural and intuitive way than using low level languages or libraries.</p><p>Some examples of front end languages or frameworks for snarks are:</p><ul><li><a href="https://github.com/akosba/xjsnark">xJsnark: A framework that uses Java as a front end language and provides various features for developing efficient snark circuits for cryptographic applications</a>.</li><li><a href="https://minaprotocol.com/blog/snarky-a-high-level-language-for-verifiable-computation">Snarky: A language embedded in OCaml that provides a high level syntax and semantics for writing verifiable computations using snarks</a>.</li><li>ZoKrates: A domain specific language for writing snark circuits that supports various back ends and platforms.</li></ul><h3>HOW FRONT END ARE BUILD ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o497Mc99eC9qdHh2dom-jA.jpeg" /><figcaption>HOW PROVER AND VERIFIER RUN SNARK FOR CIRCUIT SATISFIABILITY</figcaption></figure><p><a href="https://eprint.iacr.org/2016/260">The prover and verifier run the snark for circuit satisfiability as follows</a>:</p><ul><li>The prover and verifier agree on a circuit C that represents the computation or statement that the prover wants to prove. The circuit C takes some public inputs x and some secret inputs w and produces some outputs y. The prover knows x, w and y, while the verifier only knows x and y.</li><li>The prover and verifier also agree on a structured reference string (SRS) that contains some public parameters that are generated by a trusted setup or a multi-party computation protocol. The SRS depends on the size and structure of the circuit C, but not on the specific inputs or outputs.</li><li>The prover uses the SRS and the inputs x and w to generate a snark proof π that attests to the validity of the computation or statement. The proof π is a short string that does not reveal any information about w or any intermediate values of the circuit C.</li><li>The verifier uses the SRS and the inputs x and y to verify the snark proof π. The verification is a fast and simple algorithm that checks if π is consistent with x, y and C. If the verification succeeds, the verifier is convinced that the prover knows w such that C(x, w) = y.</li></ul><p><a href="https://timroughgarden.github.io/fob21/reports/r4.pdf">An example of a circuit satisfiability problem that can be proved using snarks is SHA-256 hashing</a>. The circuit C takes a message m as a public input and a hash h as a secret input, and outputs 1 if h is the SHA-256 hash of m, and 0 otherwise. The prover wants to prove to the verifier that they know h without revealing it. They can use snarks to generate and verify a proof π that convinces the verifier that C(m, h) = 1.</p><h3>HOW BACKEND OF SNARKS WORKS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wm6K14N3xWM8F5JiPB-iOQ.jpeg" /></figure><p>We don’t need to run our trusted setup again and again even if we tweak the circuits, if we use a snark system that has a universal or updatable trusted setup. A universal trusted setup means that the same public parameters can be used for any circuit or statement of a given size or less, while an updatable trusted setup means that the public parameters can be extended to support larger circuits or statements without compromising the security. Both of these methods allow us to reuse the same trusted setup for different or modified circuits or statements, as long as they fit within the size limit or the update scheme of the snark system.</p><h4>WHAT IS R1CS?</h4><p><a href="https://www.codecademy.com/resources/blog/front-end-vs-back-end/">The front end takes a computation, such as a program or a function, and transforms it into a <strong>rank-1 constraint system (R1CS)</strong>, which is a set of equations involving only additions and multiplications of field elements4</a>. A field is a mathematical structure where you can add, subtract, multiply, and divide any two elements, except for zero in the case of division. A field element is an element of a field, such as an integer modulo some prime number.</p><p>The R1CS format is not very human-readable, so it is usually generated by a compiler from a higher-level language. For example, if we want to prove that we know the factors of a large number N, we can write a program that takes two numbers p and q as inputs and outputs N = p * q. The front end will then convert this program into an R1CS that represents the same computation.</p><p>The back end takes the R1CS and generates a proof that shows that the prover knows a valid assignment of values to the variables in the R1CS that satisfies all the equations. The proof is very short and can be verified quickly by anyone who knows the R1CS and some public information. <a href="https://www.coursera.org/articles/front-end-vs-back-end">The proof does not reveal anything about the values of the variables or the secret inputs</a>.</p><p>The back end uses various mathematical techniques to generate and verify the proof, such as elliptic curves, pairings, polynomial commitments, and interactive oracle proofs. There are different types of snarks with different trade-offs in terms of efficiency, security, and trust assumptions. <a href="https://www.hackerrank.com/blog/front-end-back-end-full-stack/">Some examples of snark back ends are Pinocchio, Groth16, Sonic, Plonk, and Marlin</a>.</p><p>To give a simple example of how a snark works, let’s say Alice wants to prove to Bob that she knows the factors of N = 143 without revealing them. She can use a snark as follows:</p><ul><li>She writes a program that takes two inputs p and q and outputs N = p * q.</li><li>She uses a front end compiler to convert this program into an R1CS with three variables: p, q, and N.</li><li>She uses a back end protocol to generate a proof that she knows values for p and q that satisfy N = p * q. She also computes some public information that Bob will need to verify the proof.</li><li>She sends the proof and the public information to Bob. She does not send p or q or N.</li><li>Bob uses the same R1CS and the public information to verify the proof. He does not learn anything about p or q or N.</li></ul><p>By using a snark, Alice can convince Bob that she knows the factors of 143 without revealing them or doing any heavy computation on her side. Bob can verify her claim in a few milliseconds without trusting her or doing any heavy computation on his side. This is an example of how snarks can enable privacy-preserving verifiable computations.</p><h3>HOW SNARKs SATISFY THE CIRCUITS OR R1CS(majorily used)?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PjZfsFiKc509WNCRPqt65w.jpeg" /><figcaption>A UNIFIED WAY OF HOW SNARKS SATISFY THE CIRCUITS.</figcaption></figure><p>Well all snarks are designed with these 3 steps paradigm but zk cash has one exception as it was snark to be deployed in practice. But some of snarks are not designed with these 3 steps but most of the circuit satisfiability snarks are. Well with z-cash which is still in use the exception is outside this paradigm is circuit specific trusted setup.</p><h4>POLYNOMIAL- IOP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gUbHa-sUIQBsEDv97bjn_Q.jpeg" /><figcaption>SO HOW IT WORKS….</figcaption></figure><p><a href="https://crypto.stackexchange.com/questions/103407/what-would-be-the-degree-or-range-of-the-degree-of-the-polynomial-used-in-real">Polynomial IOP in SNARKs is a term that refers to the use of polynomial interactive oracle proofs (PIOPs) as a building block for constructing succinct non-interactive arguments of knowledge (SNARKs)</a> . <a href="https://eprint.iacr.org/2023/1067.pdf">PIOPs are interactive protocols between a prover and a verifier, where the prover wants to convince the verifier that a given statement is true, and the verifier can query the prover on oracles that represent polynomials related to the statement</a> . <a href="https://eprint.iacr.org/2023/1067.pdf">By using polynomial commitment schemes, PIOPs can be compiled into SNARKs, which are non-interactive and have short proofs that can be verified in sublinear time</a> .</p><p>Polynomial IOP in SNARKs is an important technique for achieving efficient and secure zero-knowledge proofs for various computational problems. <a href="https://eprint.iacr.org/2023/1067.pdf">For example, one can use polynomial IOP in SNARKs to prove the validity of an EdDSA signature, the correctness of a Merkle tree root, or the satisfiability of a boolean or arithmetic circuit</a> .</p><p><a href="https://eprint.iacr.org/2023/1067.pdf">Polynomial IOP in SNARKs also has desirable properties such as simulation extractability, which means that the proof does not reveal any information about the witness, and weak unique response, which means that the proof is unique up to negligible probability</a> .</p><p>SO, IN REAL LIFE SCHEME THE PROVER CANT SEND THE WHOLE GIANT POLYNOMIAL TO THE VERIFIER . AND THE VERIFIER TO PROOF THE WHOLE PROOF AT ONE TIME AND THATS WHERE POLYNOMIAL COMMITMENT COMES IN….</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7DaxGUJZdPUuVmz_tCUw4A.jpeg" /><figcaption>THIS IS ALL PROVER NEED AS HE CANT SEND THAT GIGANTIC MATHEMATICAL CONFUSION</figcaption></figure><p>A polynomial commitment scheme is a cryptographic primitive that allows a prover to commit to a polynomial with a short string, called the commitment, that can be used by a verifier to confirm claimed evaluations of the committed polynomial, without revealing the entire polynomial .</p><p>A polynomial commitment scheme has the following properties:</p><p>- Binding: The prover cannot change the committed polynomial after generating the commitment, or open the commitment to different polynomials or evaluations.</p><p>- Hiding: The verifier cannot learn anything about the committed polynomial or its evaluations from the commitment, except what is revealed by the prover during the opening phase.</p><p>- Homomorphic: The commitment supports some algebraic operations on the committed polynomials, such as addition, subtraction, or multiplication by a scalar. This allows the prover to commit to multiple polynomials and open their linear combinations.</p><p>One example of a polynomial commitment scheme is the KZG/Kate scheme, which is based on pairings and relies on the hardness of the discrete logarithm problem. In this scheme, the commitment is a single group element, and the opening proof is also a single group element. The verifier can check the validity of the opening proof using a pairing equation.</p><p><strong>Polynomial commitment schemes are useful tools for reducing the communication and computation costs in various cryptographic protocols, such as verifiable secret sharing, zero-knowledge sets, credentials, and content extraction signatures.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wJl53fbQcv2R8Stf7wJuWQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s9lpYublxh9VWAxPLZSDBw.jpeg" /><figcaption>HOW DIFFERENT IOP AND COMMITMENTS INTERACT</figcaption></figure><p>Different polynomial IOPs may use different polynomial commitment schemes, depending on the properties and assumptions they require. <a href="https://cacr.uwaterloo.ca/techreports/2010/cacr2010-10.pdf">For example, some polynomial IOPs use KZG commitments, which are based on bilinear pairings and require a trusted setup</a> . <a href="https://eprint.iacr.org/2020/1022.pdf">Others use FRI commitments, which are based on Reed-Solomon codes and do not require a trusted setup</a> . The choice of polynomial commitment scheme affects the efficiency, security, and transparency of the resulting proof system.</p><p>IN SAYING WE CAN SAY</p><p><strong>SNARKs cost = cost of polynomial IOPs + cost of polynomial commitment</strong>.</p><p>The cost of a SNARK depends on several factors, such as the size and complexity of the statement, the choice of arithmetization technique, the type and number of oracles used, and the cryptographic assumptions and tools employed. Some common metrics to measure the cost of a SNARK are:</p><p>- Prover time: This is the amount of time (or CPU cycles) that the prover needs to generate a proof.</p><p>- Verifier time: This is the amount of time (or CPU cycles) that the verifier needs to check a proof.</p><p>- Proof size: This is the length (or number of bits) of the proof that the prover sends to the verifier.</p><p>- Setup size: This is the length (or number of bits) of the common reference string (CRS) that both parties need to agree on before starting the proof system. Some SNARKs require a trusted setup, where the CRS is generated by a trusted party who must then destroy some secret information. Other SNARKs are transparent, where the CRS can be generated by anyone without any secrets.</p><p>The cost of a SNARK can vary widely depending on the specific construction and implementation. For example, some recent SNARKs based on polynomial commitments can achieve prover times in the order of seconds or minutes, verifier times in the order of milliseconds, proof sizes in the order of kilobytes, and setup sizes in the order of megabytes or gigabytes.</p><p><strong>WHY SOME POLYNOMIAL IOPs CANNOT USE SOME POLYNOMIAL COMMITMENTS?</strong></p><p>Some polynomial IOPs cannot use some polynomial commitment schemes because they have different requirements and assumptions that may not be compatible. For example, some polynomial IOPs may need a polynomial commitment scheme that is homomorphic, meaning that it can support operations on committed polynomials without opening them. Other polynomial IOPs may need a polynomial commitment scheme that is transparent, meaning that it does not require a trusted setup or a common reference string. <a href="https://cacr.uwaterloo.ca/techreports/2010/cacr2010-10.pdf">Some polynomial commitment schemes may not satisfy these properties, or may have other drawbacks such as large proof sizes, high computational costs, or strong security assumptions</a> .</p><h3>CLASSES OF IOPs (at high level)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cZuW_90o_U4UfdVGAAV8mA.jpeg" /></figure><p>MIP stands for multi-prover interactive proof, which is a generalization of IP (interactive proof) where the verifier can interact with multiple provers who do not communicate with each other. MIPs can achieve higher soundness and lower communication complexity than IPs, but they also require more computational power and coordination from the provers.</p><p>IP based SNARKs are SNARKs that are derived from IPs by applying some cryptographic techniques, such as hash functions, signatures, or fully homomorphic encryption. The idea is to use the IP as a starting point, and then compile it into a non-interactive proof by either removing the interaction or hiding it inside some cryptographic primitive. For example, one can use the Fiat-Shamir heuristic to transform an IP into a non-interactive proof by replacing the verifier’s challenges with hash values of the transcript. Alternatively, one can use fully homomorphic encryption to transform an MIP into a non-interactive proof by encrypting the messages between the verifier and the provers, and then using an extractable homomorphism property to extract the witness from the ciphertexts.</p><p>MIP based SNARKs are SNARKs that are directly constructed from MIPs without relying on IPs. The idea is to use MIPs that have special properties, such as low-degree testing or linear PCPs, that allow the verifier to check the validity of the proof by sampling a few random points from the transcript. For example, one can use an MIP for delegating computation that extends insights from a powerful IP protocol by Goldwasser et al., and then use a linear PCP to encode the transcript into a polynomial that can be verified by sampling a few random points. Alternatively, one can use an MIP for NP languages that is based on low-degree testing, and then use polynomial commitments to commit to the transcript and open it at random points.</p><p>Both MIP and IP based SNARKs have advantages and disadvantages. MIP based SNARKs can achieve better asymptotic efficiency and stronger security assumptions than IP based SNARKs, but they also require more complex constructions and techniques. IP based SNARKs can be simpler and more practical than MIP based SNARKs, but they also rely on stronger cryptographic assumptions and heuristics .</p><p>TALK ABOUT THIS MORE IN THE PUBLICATION OF SNARKs ON WEU FOUNDATION MEDIUM CHANNEL. WE HAVE LIVE SESSIONS TOO YOU CAN JOIN IN USING THIS LINK — <a href="https://chat.whatsapp.com/FEspEUKcsHLJvqzlhollWz">https://chat.whatsapp.com/FEspEUKcsHLJvqzlhollWz</a></p><h3>FOUR CLASSES OF COMMITMENT SCHEMES</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YtPfAZpEzQBB8Ue_SjOQOg.jpeg" /><figcaption>THOUGH 4TH ONE IS NOT PRACTICAL FOR USE . SO IGNORE IT LIKE YOU IGNORE YOURSELF</figcaption></figure><p>COMMITMENT SCHEMES mentioned in green are the popular and offcourse you know why because these are used in blockchain settings and you know why because of their shortest proof sizes and you know why because of why shortest proofs because they can be stored on chain and you why shortest proofs because of low verification cost … and i can carry on for you know whyyyyyyyyy……</p><p>As not transparent and nor post quantum are constant sizesss while transparent but not post quantum are log size and both transparent and post quantum based are polylog size in nature of evaluating the proof sizes.</p><h3>A FIGHT BETWEEN SNARKS TRILEMMA SAME LIKE BLOCKCHAIN TRILEMMA</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pK4leU1lGd7k3cgaqXlpCQ.jpeg" /></figure><p>YOU CAN READ IT THERE ONLY IT WRITTEN IN THE SLIDE…..</p><h4>ONGOING WORK CURRENTLY RESEARCHERS ON PLANET EARTH</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HXa7lSNRlqPOl0hhhfQ_MQ.jpeg" /><figcaption>ITS STILL IN RESEARCH NOT IN IMPLEMENTATION…</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hha_txurpDUg-REi4ZCPwg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fet-RPNaLDCnJAwZAiLVFQ.jpeg" /><figcaption>WHY WE HAVE TO OR WE SHOULD USE ROLLUPS</figcaption></figure><p>Rollups are a type of Layer 2 scaling solution for blockchains, which means they aim to increase the throughput and efficiency of transactions on a blockchain network, such as Ethereum, by processing them off the main chain and then submitting them as a single batch. <a href="https://www.ledger.com/academy/what-are-blockchain-rollups">Rollups can help reduce the congestion and fees on the main chain, while maintaining its security and decentralization</a> .</p><p><strong>OKAY LETS TALK ABOUT SOME IDEAS DESIGNED UNDER ROLLUPS …. AND HERE WE GOOOO….</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KhB5f3XBFHshZCGTuKTTJA.jpeg" /></figure><p>Here is the first idea where</p><p>A weak verifier is a verifier that has limited computational power and resources, such as a mobile device or a browser. A weak verifier cannot perform expensive operations, such as executing complex circuits or verifying large proofs. A weak verifier may also have limited network bandwidth or storage capacity. <a href="https://fisher.wharton.upenn.edu/wp-content/uploads/2020/09/Thesis_Terrence-Jo.pdf">Therefore, a weak verifier needs a proof system that is succinct, meaning that the proof size is small and independent of the complexity of the statement, and efficient, meaning that the verification time is fast and sublinear in the complexity of the statement</a> .</p><p>An untrusted prover is a prover that may be dishonest or malicious, and may try to cheat the verifier by sending an invalid or fraudulent proof. An untrusted prover may have an incentive to deceive the verifier, such as gaining an advantage or hiding some information. <a href="https://eprint.iacr.org/2021/673.pdf">Therefore, an untrusted prover needs a proof system that is sound, meaning that the probability of accepting an invalid proof is negligible, and zero-knowledge, meaning that the proof does not leak any information about the secret input or witness of the prove</a>r.</p><h3>HOW WE GOING TO PUL THIS OUT?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ApRnpK23A8Qiq6IihQRMw.jpeg" /></figure><p>However, you have an interesting idea of a rollup where we don’t store state on chain, but rather we store the commitment hash on chain. A commitment hash is a cryptographic hash that represents the state of the rollup, but does not reveal any details about it. By storing only the commitment hash on chain, we can save more space and reduce the fees for submitting batches.</p><p>However, there are also some challenges and trade-offs with this idea. For example:</p><ul><li>How do users access their state data? If we don’t store state on chain, then users need another way to access their state data, such as their account balance or transaction history. One possible solution is to use a decentralized storage network, such as IPFS or Swarm, where users can store and retrieve their state data using the commitment hash as a key. However, this introduces another layer of complexity and dependency for the rollup system.</li><li>How do users verify their state data? If we don’t store state on chain, then users need another way to verify that their state data is correct and consistent with the commitment hash. One possible solution is to use zero-knowledge proofs, where users can generate and verify proofs that their state data matches the commitment hash. However, this requires more advanced cryptography and computation for the users.</li><li>How do users dispute invalid batches? If we don’t store state on chain, then users need another way to dispute invalid batches that are submitted by malicious or faulty operators. One possible solution is to use fraud proofs, where users can provide evidence of an invalid transaction or state transition in a batch. However, this requires more interaction and latency for the dispute resolution process.</li></ul><p><strong>BUT HOW WE CAN PULL THIS OUT WITH DATA AVAILABILITY LAYER</strong></p><h4>EIP-4444 AND HOW ITS IDEA LOOK FOR ROLLUPS</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VgRBXQdjocK-atLgMbTdng.jpeg" /><figcaption>KIND OF DATA AVAILABILITY LAYER LIKE EIGEN LAYER BUILD</figcaption></figure><p>EIP 4444 proposes that nodes prune data that is over one year old. It specifies that nodes should not serve headers, block bodies, and receipts older than one year on the p2p network. Hence, nodes will not be responsible for serving historical data older than one year ago.</p><p>The motivation behind EIP 4444 is to reduce the disk space and bandwidth requirements for users and clients. Historical data currently occupies more than 400 GB of disk space and is growing at a rate of 140 GB per year¹³. This data is not necessary for validating new blocks, so once a client has synced the tip of the chain, historical data is only retrieved when requested explicitly over the JSON-RPC or when a peer attempts to sync the chain. By pruning the history, EIP 4444 reduces the disk requirements for users to around 100 GB.</p><p>Pruning history also allows clients to remove code that processes historical blocks. This means that execution clients don’t need to maintain code paths that deal with each upgrade’s compounding changes.</p><p>Finally, this change will result in less bandwidth usage on the network as clients adopt more lightweight sync strategies based on the PoS weak subjectivity assumption. Weak subjectivity refers to the idea that nodes need some external information (such as a checkpoint) to sync with the chain after being offline for a long time.</p><p>EIP 4444 impacts the way clients bootstrap and sync. Clients will not be able to full sync using devp2p since historical data will no longer be served. Clients must use a valid weak subjectivity checkpoint to bootstrap from a more recent view of the chain. For the purpose of syncing, clients treat weak subjectivity checkpoints as the genesis block. This method is called “checkpoint sync”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*umqYGaNfdLkMzzH9343otw.jpeg" /><figcaption>YEP YEP</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VWo_fN7SFdUwTEahq2FCHQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gx3RyW9wz6vftBMTfwqx9Q.jpeg" /><figcaption>AS WE THOUGHT OUT IT DONT TURN OUT TO THAT</figcaption></figure><p>The thing this TPS is not actually transactions but it just how many transactions l2 can batch up from L1 . So dont get confused now. Basically its batching up of transactions ..</p><p>LETS EXPLORE IT……</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rvKheaD9h4PR1VRF7DPGFA.jpeg" /></figure><p>Latency is the time required to perform some action or to produce some result, and is measured in units of time, such as milliseconds or seconds. Latency indicates how long it takes for packets to reach their destination. For example, if you send a message to a friend on a chat app, the latency is the time it takes for your message to appear on their screen. Low latency means fast response time, which is desirable for interactive applications such as gaming, video conferencing, or voice over IP (VoIP).</p><p>Throughput is the number of such actions executed or results produced per unit of time, and is measured in units of data, such as bits per second (bps) or packets per second (pps). Throughput is how much data can be transmitted from one place to another in a given time. For example, if you download a file from a website, the throughput is the amount of data you receive per second. High throughput means high data rate, which is desirable for data-intensive applications such as streaming, file sharing, or backup.</p><p>The relationship between latency and throughput is influenced by the bandwidth of the network, which is the maximum amount of data that can be transferred in a given time. Bandwidth is determined by the physical characteristics of the network, such as the type of cable, router, or switch used. Bandwidth is often confused with throughput, but they are not the same. Bandwidth is the theoretical limit of data transfer, while throughput is the actual amount of data transferred.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oCiCeZ71kyPQPotOFOJ9wA.jpeg" /><figcaption>pretty high latency issue around</figcaption></figure><h3>HOW WE CAN ADDRESS THESE ISSUES?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PyoxgTjN8y5l9sxHF6bL6Q.jpeg" /></figure><p>One way to achieve recursion in zero-knowledge proofs is to use a folding scheme, which is a cryptographic primitive that allows one to compress two instances of a problem into one instance, such that verifying the compressed instance is equivalent to verifying the original instances. For example, suppose we have two instances of a boolean circuit satisfiability problem, C1 and C2, and we want to prove that both of them are satisfiable. We can use a folding scheme to combine C1 and C2 into a single circuit C, such that C is satisfiable if and only if both C1 and C2 are satisfiable. Then, we can generate a proof for C instead of generating two proofs for C1 and C2 separately. This reduces the size of the proof and the number of steps required to generate it.</p><p>Another way to achieve recursion in zero-knowledge proofs is to use a recursive proof system, which is a proof system that can verify its own proofs as part of its verification algorithm. For example, suppose we have a sequence of computations F1, F2, …, Fn, where each Fi takes the output of Fi-1 as its input, and we want to prove that we have correctly executed all of them. We can use a recursive proof system to generate a proof for Fn that also includes a proof for Fn-1 as part of its input. Then, we can generate a proof for Fn-1 that also includes a proof for Fn-2 as part of its input, and so on, until we reach F1. This way, we can generate a single proof for the entire sequence of computations, instead of generating n proofs for each computation separately. This also reduces the size of the proof and the number of steps required to generate it.</p><p>Recursion in zero-knowledge proofs can help the prover’s latency by unlocking parallelism in two ways:</p><ul><li>First, by reducing the size and complexity of the proof, recursion can make the prover’s computation faster and more efficient. The prover can use less resources and time to generate a recursive proof than to generate multiple non-recursive proofs.</li><li>Second, by allowing the prover to generate multiple proofs at the same time, recursion can make the prover’s computation more concurrent and scalable. The prover can use multiple threads or machines to generate different parts of a recursive proof in parallel, without waiting for the verification of the previous parts.</li></ul><p>Therefore, recursion in zero-knowledge proofs is a powerful technique that can improve the performance and scalability of proving complex computations.</p><p>HOW SNARKS ARE DESIGNED AND WHATS THE ROLE IN ROLLUPS IS SO IMPORTANT TO UNDERSTAND BEFORE DESIGNING ROLLUPS OR MAKING SOME PRIVACY BASED SOLUTIONS AND MANY OTHER APPLICATIONS TO BUILD OUT</p><p>ROLLUPS CAN BE GREAT WITH ADDING AMAZING FUNCTIONALITIES LIKE PARALLELISM BUT AT THE SAME TIME FUTURE OPENS A DOOR FOR ADDING UNIVERSALITY THROUGH SMALL PROOFS.</p><p>THANK YOU FOR READING AN IMMENSE EXPERIENCE , IF YOU WANT TO KNOW MORE OR WANT TO JOIN LIVE BATCHED YOU CAN JOIN THIS GROUP UP HERE — <a href="https://chat.whatsapp.com/FEspEUKcsHLJvqzlhollWz">https://chat.whatsapp.com/FEspEUKcsHLJvqzlhollWz</a></p><p>JOIN THE MOST DECENTRALISED FOUNDATION BUILDING SELF SOVEREIGN APPLICATIONS</p><h3>WEU FOUNDATION</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8062c160f99" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ZERO KNOWLEDGE PROOFS AND  EVOLUTION IN THEIR MODELS.]]></title>
            <link>https://weufoundation.medium.com/evolution-of-models-of-zero-knowledge-proofs-9c92f3540ca7?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c92f3540ca7</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[zero-knowledge-proofs]]></category>
            <category><![CDATA[crypt]]></category>
            <category><![CDATA[crypto-research]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Mon, 19 Jun 2023 22:38:36 GMT</pubDate>
            <atom:updated>2023-12-30T07:48:55.727Z</atom:updated>
            <content:encoded><![CDATA[<p>ZERO KNOWLEDGE PROOFS AND 🧬 EVOLUTION IN THEIR MODELS.</p><p>Written by — Fardeen khan ( <a href="https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app">https://www.linkedin.com/in/fardeen-khan-093938212?utm_source=share&amp;utm_campaign=share_via&amp;utm_content=profile&amp;utm_medium=android_app</a> )</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PwfGEgaKSOjcJbsHbPRW7g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OxFlil7N762oDr56DZeVsA.jpeg" /><figcaption>The game where prover prove without witness</figcaption></figure><p>As Weu foundation team and Dev’s are working and researching around zk proofs and 🆔 infrastructure. As we are building a zk proof based GitHub , where Dev’s can contribute being anonymous and get direct incentives to their dashboard.</p><p>The same way zk proof has two main properties which are soundness and zero knowledge as the name suggests. Today will go through the whole evolution 🧬 cycle of zk proofs.</p><p>Zero-knowledge proofs are a fascinating topic in cryptography. They are a way of proving that a certain statement is true without revealing any additional information beyond the truth of the statement itself. For example, you can prove that you know the password to a website without actually typing it or showing it to anyone. Zero-knowledge proofs have many applications in security, privacy, and authentication.</p><p>There are different types of zero-knowledge proofs, depending on how they are implemented and what properties they have. Some of the main types are:</p><p><strong>Interactive zero-knowledge proofs</strong></p><p>These require communication between the prover and the verifier, where the verifier asks some random questions or challenges to the prover, and the prover responds with some evidence or answers that convince the verifier of the statement’s validity. The prover must be able to answer any challenge correctly if the statement is true, and must have a very low probability of answering correctly if the statement is false. The verifier must not learn anything from the interaction other than the validity of the statement. An example of an interactive zero-knowledge proof is the Ali Baba cave story, where one person proves to another that they know the secret word to open a door in a cave without revealing the word itself.<br><strong>Non-interactive zero-knowledge proofs</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1vvmagbfCLTx6JSqEs_piQ.jpeg" /><figcaption>NIZK needs common random string to be non interactive</figcaption></figure><p>These do not require communication between the prover and the verifier, but instead rely on some common reference string or public parameter that both parties can access. The prover generates a proof using this parameter and sends it to the verifier, who can check its validity using the same parameter. The proof must not reveal anything about the statement or the secret information used to generate it. An example of a non-interactive zero-knowledge proof is the Fiat-Shamir heuristic, where one person proves to another that they know a discrete logarithm of a given value without revealing it.</p><p>The CRS does not have to be random, but it has to be sampled from a specific distribution that the NIZK protocol specifies. The CRS serves as a public parameter that allows the prover to generate a proof that convinces the verifier of the validity of a statement, without revealing any additional information beyond the truth of the statement itself.</p><h3>Simulation — Extractability</h3><h3>Simulator</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2tqgwobmjc9XxpEAGBJkQA.jpeg" /><figcaption>Sim. generating w for verifier using crs without a witness</figcaption></figure><p>A simulator is an algorithm that can generate a transcript of a zero-knowledge proof without knowing the witness, such that the transcript is indistinguishable from a real one produced by an honest prover and verifier. The simulator is used to show that the verifier learns nothing more than the validity of the statement from the proof, since the same transcript could have been generated by the simulator without any knowledge of the witness.</p><p>The prover can use the simulator to prove that he is not leaking any information in the proof, or to deny that he participated in a protocol by claiming that the transcript was simulated5. The prover can also use the simulator to construct a non-interactive zero-knowledge proof by applying the Fiat-Shamir heuristic, which replaces the verifier’s challenge with a hash of the prover’s commitment and the statement. This way, the prover can generate a proof without interacting with the verifier, and the simulator can still simulate a proof by choosing a random challenge and working backwards to find a matching commitment.</p><h3>Extractability</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gWVDhQcDtMVRfNXLiez8qg.jpeg" /><figcaption>Extractability</figcaption></figure><p>Extractability is important for zero-knowledge proofs because it prevents the prover from cheating or lying to the verifier. It also implies that the proof is an argument of knowledge, meaning that the prover actually knows a witness for the statement and not just a proof. Extractability also enables applications such as delegation, where a verifier can delegate the verification of a proof to another party without revealing the witness.</p><h3>Proof sizes and it’s construction</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jYTPpMloQaBmMiAkZYu5vQ.jpeg" /><figcaption>Sizes of the proof in relation with its protocols</figcaption></figure><p>The size of the proofs in zero-knowledge proofs depends on the type and construction of the proof system. Some of the most common types of zero-knowledge proofs are:</p><p>zk-SNARKs: Zero-Knowledge Succinct Non-Interactive Argument of Knowledge. These are proofs that are very short (around 288 bytes) and efficient to verify, but require a trusted setup and a common reference string (CRS) to generate.<br>zk-STARKs: Zero-Knowledge Scalable Transparent Argument of Knowledge. These are proofs that are transparent (do not require a trusted setup or a CRS) and scalable (can handle large and complex computations), but have a larger proof size (up to 250 kB) and verification cost than zk-SNARKs.<br>Bulletproofs: These are proofs that are also transparent and do not rely on pairings or elliptic curves, but use inner product arguments instead. They have a smaller proof size (around 2 kB) than zk-STARKs, but a higher verification cost than zk-SNARKs.<br>The choice of the proof system depends on the trade-offs between proof size, verification cost, security assumptions, and transparency. Different applications may have different requirements and preferences for these factors. For example, blockchain applications may prefer smaller proof sizes to reduce network bandwidth and storage costs, while privacy applications may prefer transparent proofs to avoid trust issues.</p><h3>Maintaining, Validating and updating the state</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_jL_JmFmilHWoFUGdHM1lw.jpeg" /><figcaption>Maintaining the state of the blockchain</figcaption></figure><p>How the state of the blockchain is updated with root hash of the address tree and the root hash of the balance tree.</p><p>And you can see how a transaction is been done using from whom to who , amt, sig.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ue-hP2luC3cNDFB9lABcxQ.jpeg" /><figcaption>Black depicts the previous state and the 🟣 depicts the current state .</figcaption></figure><p>Instance of language has hash of the address and balance tree.</p><p>w = how much balance to be transferred, Transaction).</p><h3>Checking validity of the transaction</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tiWc-Ckmp0UfGNhwCOwT5g.jpeg" /><figcaption>So the parrot sends up 2 units to the vulture</figcaption></figure><p>How the state is being updated.</p><p>So the balance of parrot is 10 .</p><p>He has send 2 , the balance tree will check if it has enough balance.</p><p>If it has it will move to the next function, the sender Sig. has to verify ( addr , sig , tx )= 1.</p><h3>Updating global state</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vc7UKNwvBuUFBzVSdwfVJg.jpeg" /><figcaption>Pinky depicts full node in the tree</figcaption></figure><p>Which means it maintains the full node which means it updates and download the whole blockchain.It maintains the whole address tree and balance tree since genesis.</p><p>Well here comes zk rollups in place…</p><h3>Zk rollups</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JrhX79SIF88eQswh0-YaFA.jpeg" /><figcaption>Zk rollups</figcaption></figure><p>How light client which don’t maintain the full node still update the and verify the information inside the block. So basically a validator roll up all the transaction done and put it in the block with the hash of the root of the address tree. And the block contains other parts to such as the proof , address, tx and the balance of the balance tree.</p><p>As rollups are trusted party setups where a multi party ensures that structured random string generated by them has been known to no one.</p><p>The prover can use the SRS to create a zk-SNARK proof that attests to the validity of a batch of transactions on the zk rollup. The proof is then submitted to the main chain along with some minimal data that defines the state transition of the rollup. The verifier can use the same SRS to check the proof and update the rollup state accordingly.</p><p>The SRS is important for zk rollups because it enables the generation and verification of succinct and efficient zero-knowledge proofs, which are essential for scaling Ethereum and other blockchains. However, the SRS also introduces some challenges, such as the need for a secure and transparent trusted setup.</p><p>So basically the client can also verify it by using root of the address tree , root of the old Bal. root of the new balance, the proof, srs — generated by the trusted setup and basically that is all a roll-up is .</p><p>But the paradox in rollups is we don’t care about zero knowledge, we want the proof as small as possible it can be.</p><h3>Proofs and their implications</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c2ICTRiEy8q6_1QY_RgQ0g.jpeg" /><figcaption>Snarks but their implications too</figcaption></figure><p>Zk- snarks — Zero knowledge succinct non interactive argument of knowledge .</p><p>A zk-SNARK has the following properties:</p><p><strong>Zero-knowledge</strong>: if the statement is true, a verifier does not learn anything beyond the fact that the statement is true.<br><strong>Succinct</strong>: The size of the proof needs to be small enough to be verified in a few milliseconds.<br><strong>Non-Interactive</strong>: Only one set of information is sent to the verifier for verification, therefore there is no back and forth communication between the prover and verifier.<br><strong>ARgument</strong>: A computationally sound proof: soundness holds against a prover that leverages polynomial-time, i.e. bounded computation.<br> <strong>Knowledge</strong>: The proof cannot be constructed without access to the witness (the private input needed to prove the statement).</p><p><strong>But Snarks has implications too-</strong></p><h3>Prover runtime</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3XAddZh31RFQ6ikncRrrlQ.jpeg" /><figcaption>No. Of constraints to prove</figcaption></figure><p>Different zk-SNARK constructs have different prover run times. For example, Groth16 has a prover run time of O(n log n), where n is the number of gates in the circuit. Fractal has a prover run time of O(n log^2 n), where n is the number of wires in the circuit.</p><p>Halo has a prover run time of O(n log^3 n), where n is the number of constraints in the circuit. SuperSonic-CG has a prover run time of O(n log^2 n), where n is the degree of the polynomial representing the circuit.</p><p>Generally, a lower prover run time means a faster proof generation, but it may also come with trade-offs such as larger proof sizes or longer verification times. Therefore, choosing a zk-SNARK construct depends on the specific application and its requirements.</p><h3>Constant sized snarks</h3><p>Constant sized snarks required a structured reference string which means they have to rely on 3rd party.</p><p>Let’s get a little more in what are the different ways that a reference string is structured.</p><h3>GENERATING A REFERENCE STRING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IegJa9l_qWp4RJUOPXSk-A.jpeg" /><figcaption>4 ways to generate it</figcaption></figure><p>Where will talk about the how the setups are being initiated to generate srs differently.</p><p>Let’s first talk about</p><h3>Trusted setup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TLyRn9On-MhozWYVpiPNKA.jpeg" /><figcaption>Trusted setup</figcaption></figure><p>Trusted setups are procedures that involve more than one party to produce the standard parameters that a proof system or similar cryptographic protocols rely on. During these setups, random numbers (secrets) are generated, encrypted, used to generate the data, and then deleted to ensure the protocol remains secure. As long as at least one party in the setup behaves honestly and destroys its secret, the entire setup can be considered secure.</p><p>But the problem is this case is impossible because Byzantine fault tolerance in this case is around less than 1 so not possible</p><h3>Sub — version</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wUnEcmcZz3tFAeysrx6A7w.jpeg" /><figcaption>Subversion</figcaption></figure><p>Subverted setups are setups where the prover can choose or manipulate the parameters of the proof system, such as the modulus of an RSA group, and the verifier does not know the group order or other properties of the parameters. Subverted setups pose a challenge for zero-knowledge protocols, because they may compromise the security or soundness of the proofs. For example, a malicious prover may be able to create fake proofs or learn information from the verifier’s queries.</p><p>There are different approaches for designing zero-knowledge protocols that are secure under subverted setups, depending on the type of proof system and the security assumptions. Some of the common approaches are:</p><p><strong>Subversion-ZK</strong>: These are protocols that achieve zero-knowledge even if the prover can choose or manipulate the parameters of the proof system. The verifier does not need to trust the parameters, but only needs to check their correctness using a public algorithm. This approach is used by some zk-SNARK constructions, such as Zether and ZEXE..<br><strong>Subversion-SND</strong>: These are protocols that achieve soundness even if the prover can choose or manipulate the parameters of the proof system. The verifier does not need to trust the parameters, but only needs to rely on a computational assumption over them. This approach is used by some zk-SNARK constructions, such as Groth16 and Fractal.<br><strong>Subversion-Resistant</strong>: These are protocols that achieve both zero-knowledge and soundness even if the prover can choose or manipulate the parameters of the proof system. The verifier does not need to trust or check the parameters, but only needs to rely on a computational assumption over them. This approach is used by some zk-STARK constructions, such as Aurora and Ligero.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g9w6fkeI1dxfm9qRGTZVPQ.jpeg" /><figcaption>Subversion show that some properties can exist together.</figcaption></figure><h3>Transparent 🪟 setups</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w1Ija_Mc55xiGWqphvo8qQ.jpeg" /><figcaption>Also known as starks</figcaption></figure><p>Transparent setups are setups where the parameters of the proof system or similar cryptographic protocols are generated without relying on any trusted parties or secrets. Transparent setups are desirable for some applications, such as cryptocurrencies, where trust is minimal and verifiability is crucial..</p><p>There are different methods for generating transparent setups, depending on the type of proof system and the security assumptions. Some of the common methods are:</p><p><strong>Hash-based setups</strong>: These are setups where the parameters are derived from a hash function, such as SHA-256 or Pedersen hash, that is assumed to behave like a random oracle. The parameters can be computed by anyone who knows the hash function and some public inputs, such as a domain separator or a random beacon. This method is used by some zk-SNARK constructions, such as ZKBoo and ZKB++.<br><strong>Lattice-based setups</strong>: These are setups where the parameters are derived from a lattice problem, such as Learning With Errors (LWE) or Short Integer Solution (SIS), that is assumed to be hard to solve. The parameters can be computed by anyone who knows the lattice problem and some public inputs, such as a modulus or a basis. This method is used by some zk-STARK constructions, such as Aurora and Ligero.<br><strong>Group-based setups</strong>: These are setups where the parameters are derived from a group problem, such as Discrete Logarithm (DL) or Decisional Diffie-Hellman (DDH), that is assumed to be hard to solve. The parameters can be computed by anyone who knows the group problem and some public inputs, such as a generator or a curve. This method is used by some zk-SNARK constructions, such as Bulletproofs and Halo.</p><h3>Multi party computation (MPC) setup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Y_M9WweJ8YVb0RN_vp37A.jpeg" /><figcaption>MPCs</figcaption></figure><p>Multi-party computation setups are procedures that involve more than one party to produce the parameters or data that a proof system or similar cryptographic protocols rely on. During these setups, each party contributes some private or secret information, such as a random number or a key, and performs some computation based on it. <a href="https://digitalprivacy.ieee.org/publications/topics/what-is-multiparty-computation">The final parameters or data are obtained by combining the contributions from each party</a>.</p><p>Multi-party computation setups are necessary for some proof systems, such as zk-SNARKs, to achieve succinctness and efficiency. However, they also introduce trust assumptions and potential vulnerabilities. <a href="https://learn.microsoft.com/en-us/azure/architecture/guide/blockchain/multiparty-compute">If the parties do not behave honestly or securely during the setup, an attacker could use their information to compromise the protoco</a>l.</p><h3><strong>AN ALTERNATIVE — UPDATABILITY</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NsKjSs0MNldyg8Y3VgjcFg.jpeg" /><figcaption>UPDATABLE SNARK PRODUCED A UNIVERSAL REFERENCE STRING</figcaption></figure><p>Updatable SNARKs are a type of zero-knowledge proof systems that allow the parameters of the proof system to be updated by any party, non-interactively and verifiably, without compromising the security or soundness of the proofs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uPg_o1PMCp90daWMUHaT-A.jpeg" /><figcaption>even one party is honest and no time bounded</figcaption></figure><p>The SRS consists of a set of public parameters that are shared between the prover and the verifier, and a set of secret parameters that are only known to the prover. The SRS can be updated by any party using a public algorithm that preserves the structure and the randomness of the SRS. <a href="https://link.springer.com/chapter/10.1007/978-3-030-84242-0_27">The updated SRS can be verified by anyone who knows the public parameters and the update algorithm</a>.</p><p>and there is no bound of participation, anyone can come update the state. and anyone can participate. and the major if you dont trust the other parties you can jump in and update by yourself and now you trust it.</p><h3>UPDATING THE REFERENCE STRING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PHn6DzugkpXMPj7eQ0cSjw.jpeg" /><figcaption>BLOCKCHAIN WITH INFO INSIDE IT</figcaption></figure><p>As you dont trust anyone or so. The idea with updatability is in blockchain we already are producing block . so what one can do when he will putting other info inside the block , they can update the state of srs and it will be changed and now you too trust the chain.</p><p>The main advantage of updatable SNARKs is that they reduce the trust assumptions and the potential vulnerabilities of the trusted setup. As long as at least one party in the setup or in the update behaves honestly and destroys its secret, the entire SRS can be considered secure. <a href="https://link.springer.com/chapter/10.1007/978-3-030-84242-0_27">Moreover, updatable SNARKs can also achieve universality, which means that they can be used for any circuit up to a maximum given size, without requiring a new setup for each circui</a>t.</p><h3>PRIVATE AGGREGATE COMPUTATIONS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7DUP2rVgNu5Ceyn2LMVoag.jpeg" /><figcaption>As there is one single party that is doing computation but still care about the prover runtime</figcaption></figure><p>why we care about prover runtime. As let suppose every prover is trying to call that one receiver who is a verifier and if the prover runtime is higher than it will cost on bandwidth to the prover .</p><p>Private aggregate computations in zk proofs are methods for computing statistical functions over the data of multiple parties, without revealing the individual data values to anyone, and proving the correctness of the computation using zero-knowledge proofs. <a href="https://eprint.iacr.org/2021/1530.pdf">Private aggregate computations can be useful for applications such as privacy-preserving data analysis, federated learning, or secure multi-party computatio</a>n</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WfY8Lsah34Ul-fDufoCZLg.jpeg" /></figure><h4>few application that can build with private aggregators computations</h4><h3>Lets talk about some cool papers in zk evolution now</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JKAt7vZWnLcOkOq-KNHEIw.jpeg" /><figcaption>WHERE 2 VERIFIERS ARE VERIFYING THE PROVER DATA</figcaption></figure><p>WELL we can make the prover more faster by sending the proof to two different verifiers. Plus they dont collude. LIKE FOR EXAMPLE</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aTYhm8GIGjcxCg5wV74vWQ.jpeg" /><figcaption>WELL HERE AS YOU AN SEE BY YOURSELF</figcaption></figure><p>SO WHAT IS HAPPENING THE PROOF IS GOING TO TWO DIFFERENT VERIFIERS. LIKE ONE CAN BE A TRUSTED PARTY LIKE ISRG AND OTHER CAN BE ANYONE. THOUGH PRIO DECIDED NOT TO COLLUDE WITH ANYONE AND IN ORDER FOR THAT CAN CHARGE A FEES OR SOOOOOO…. thus any other party can do anythingover them and they can generate a certificate for them.</p><h3>PROTOCOLS AND PROOF SIZES</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ds_mAOMcZud3q4_O9rrlkg.jpeg" /><figcaption>OH JUST A RAINBOW SLIDE BY JONATHAN</figcaption></figure><h3>WHERE ZERO KNOWLEDGE FATE LEAD TO</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d7jQ9WTt-nzDEUJjpPI3Jg.jpeg" /><figcaption>CON CLUSIONS</figcaption></figure><p>The con clusion is researchers come up with more practical proofs , the will be real time applications can be build.</p><p>Well there are lot of fields to explore in zero knowledge though you can research around a topic and build a application on top of it .</p><p>i hope you like and understand well, so now please like and share it others . so it can help them to learn around zero knowledge in deep.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c92f3540ca7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How does WEU Foundation claim to be the most Decentralized foundation in the  and how Web3 is…]]></title>
            <link>https://weufoundation.medium.com/how-does-weu-foundation-claim-to-be-the-most-decentralized-foundation-in-the-and-how-web3-is-1a311a48f61b?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a311a48f61b</guid>
            <category><![CDATA[web-3-point-0]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[weufoundation]]></category>
            <category><![CDATA[decentralized-finance]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Tue, 17 Jan 2023 16:56:42 GMT</pubDate>
            <atom:updated>2023-01-17T17:15:04.938Z</atom:updated>
            <content:encoded><![CDATA[<h3>How does WEU Foundation claim to be the most Decentralized foundation in the 🌎 and how Web3 is still centralized from its values?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N8_EX1uaOOjVrEQA66eQgA.jpeg" /></figure><p>“The world we live in needs changes in every layer to create a distributed wealth and technology”. We believe there are 5 layers by which every organization can become decentralized if they adopt it.</p><p>I will explain to you every layer of how this world works and how wealth and technology are still not distributed in a sense. And how <strong>WEU Foundation</strong> is built on top of these layers and solving every layer synchronously. Let’s dive into it.</p><p>The layer is explained from the bottom to the top of the ecosystem.</p><p>Layer 1 — Organization Structure layer</p><p>↓</p><p>Layer 2 — Incentivization layer</p><p>↓</p><p>Layer 3 — Technology layer</p><p>↓</p><p>Layer 4 — Economical/Political layer</p><p>↓</p><p>Layer 5 — Philosophical/Consensus layer</p><p>Let me take you to a brief story of the origin of bitcoin and why it created an impact at that part-time. The story didn’t start with <strong>Satoshi Nakamoto</strong> but it started with a person named <strong>Nick Szabo</strong>. In 1998, Szabo designed a mechanism for a decentralized digital currency. He called it<strong> “bit gold”</strong>. The phrase and concept of “smart contracts” were developed by Szabo in 1994 to bring what he calls the “highly evolved” practices of contract law and practice to the design of electronic commerce protocols between strangers on the Internet.</p><p>But why these things didn’t get momentum &amp; why did bitcoin get momentum in 2009? Due to crises around the globe, due to U.S. recessions, so many layoffs, &amp; that is even currently happening. And that’s how you can understand by creating a distributed technology that neither makes people adopt it nor use it.</p><p>It takes more other layers that humans and society follow. And that’s why 2009 was perfect due to everyone losing their trust in the central government and banks. As still this practice prevails after bitcoin got created.</p><p>As bitcoin is a computational mining-based resource and these mining rigs come from a lot of capital resources. So does big farms that are mining cryptocurrency emerged through either VC investors or private institutions in which the wealth always downlined from that 1% of people on the planet which can be family offices and other big private investors who are holding this wealth for generations.</p><p>In every layer, I will cover how technology can’t break other layer barriers and how we are breaking them through technology strategies and our belief to build the world’s most sharable foundation.</p><p><strong>LAYER 1: ORGANISATIONAL LAYER</strong></p><p>In WEU Foundation, hiring to even deciding who will get into the team doesn’t depend on a bunch of people taking interviews. But it depends on everyone in the foundation. So how do we say it is most decentralized for the organizational layer? How it works!?</p><p>As everyone gives their interviews for the foundation. Their CVs and GitHub are taken to a software where everyone votes using foundation soul-bound IDs in a way of YES, NO, or NEUTRAL. Based on that, the software will take the vote of the foundation members and will decide whether this candidate is suitable for the foundation or not.</p><p>Thus how few things can’t be judged by GitHub or CVs. For that, a remark is to be pit by the interviewer.</p><p><strong>LAYER 2: INCENTIVE LAYER</strong></p><p>As everyone on this planet has a way to pay their teams and people building inside their company or project. Thus to be decentralized we created a mechanism that is based on your work not on your level of authority in the foundation. This mechanism is called <strong>GDT</strong>(Generation Development Tips). GDT works based on your work and skill. How does everyone get incentivized through GDT !?</p><p>Generations are entities or projects under WEU Foundation. <strong>TIPS </strong>is a portion that will be proposed and approved for those who are building Generation 2 either by the council members or the developers working with them together.</p><p>There is an algorithm that will be applied for the distribution of tips among the proposer and awardee by the voting system of <strong>Generation 2</strong> approved by the council members of the Generation pool of Generation 2. The awardee will receive the median of the tips provided by the council members for their work and development input.</p><p>Let’s suppose there are 8 council members &amp; each has provided 20 dollars or significant tokens having the same value.</p><p>Here we use the formula to calculate the median for the distribution of the TIPS.</p><p>Median = {(n/2)the term + [(n/2) + 1]th term} / 2</p><p>If INPUTS = 20, then</p><p>The median will be — ( 20/ 2 + ( 20/2) + 1 / 2</p><p>As the median distributed will be 18 INPUTS to the awardee due to 10% of the actual TIP going to the proposer. So within the same ecosystem, someone can earn a million dollars, someone just 100 dollars based on how many repositories you build around. And thus we don’t do layoffs just because of this. It’s open source but you are getting incentivized. You reap, what you sow here.</p><p>Here’s how other centralized companies treat their employees.</p><p><a href="https://www.businessinsider.in/finance/news/some-g">https://www.businessinsider.in/finance/news/some-g</a> — GOLDMAN SACHS LAYOFF</p><p><a href="https://techcrunch.com/2022/12/22/twitter-lays-off-employees-in-public-policy-engineering/">https://techcrunch.com/2022/12/22/twitter-lays-off-employees-in-public-policy-engineering/.</a> — TWITTER LAYOFF</p><p><a href="https://www.forbes.com/sites/qai/2022/12/07/meta-layoffsfacebook-continues-to-cut-costs-by-cutting-headcount/">https://www.forbes.com/sites/qai/2022/12/07/meta-layoffsfacebook-continues-to-cut-costs-by-cutting-headcount/</a> — META LAYOFF</p><p>And many others will keep doing it until we try to change how these ecosystem work. And thus as a foundation, we decided to follow these mechanisms and other big institutions to follow the same follow-up.</p><p>How core team of the generation and project get decided?</p><p>Once the project will get on an a- chain which means it gets onto any distributed ledger. The software will decide the core team of the project based on how many repositories a person has built and directly fetching up that data from the source. And for other positions, there will be two pseudonymous entities that will judge who will get into the core.</p><p>So the core team will lead and decide for their part where future incentives will lead into. But GDT will keep running for people who still want to contribute thus decentralizing the layer of incentivization to almost.</p><p><strong>LAYER 3: TECHNOLOGY LAYER</strong></p><p>From a technology perspective, we have an ETHEREUM ecosystem where everyone is building on top of it. But still, Ethereum has its restrictions and control there.</p><p>The innovation is driven only at layer 3 which is the app layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tIgkan9JPWS4FQA7UH_RBQ.jpeg" /></figure><p>The problem comes at the consensus layer where every application built on top of it has to use Ethereum consensus. They can’t use their consensus and that’s why Cardano, Cosmos, and Avalanche come out with their consensus because there is a barrier to entry at the consensus layer.</p><p>The same thing is at the virtual machine layer where there is a barrier to entry.</p><p>Everyone building on top of Ethereum has built on EVM, rather than they can build or use their virtual machine. This makes other ecosystems like GALA, illuvium, AI come up with their virtual machine to build things.</p><p>And thus the main problem resides in that Ethereum which only provides security to apps for block execution and ordering. For other services like oracles, bridges, and sidechains they need their trust network outside of Ethereum. And that’s why $800Bn got wiped out since the crypto ecosystem started. And it’s difficult to build a trusted network.</p><p><strong>INTRODUCING INTROSPECT</strong></p><p>A new financial playground while currently building its instruments.</p><p>From 0 cost building and execution for 2 years of your services in software development, product development to marketing.</p><p>Through a mechanism where you create your company or startup metrical tokens on INTROSPECT.</p><p>A new market outside the regime of crypto and stocks that only runs on utility and gives value to humans but produces an output.</p><p>A market where VCs, private institutions, and family offices can insure some startups based on secure metrics and can stable returns based on liquidity provided and can turn into exponential returns based on the liquidity for other parties in the ecosystem.</p><p>A market where development investors a.k.a third-party developers can now be an investor in startups while taking the risk based on their skills and have a chance to get equity in future Fortune 500 while just developing their services at 0cost.</p><p>A market where liquidity can be accessed by multiple other parties like traders, market makers, liquidity pools, and traditional finances for their ecosystem.</p><p>Stable and create profit through liquidity.</p><p>And an asset-agnostic bridge 🌉 for transferring and converting your tokens into real liquidity in other markets like crypto and stocks.</p><p>If you don’t find liquidity or buyers in our market. New markets take time to emerge. Remember bitcoin is mined through emails in 2009. Thus how creating a much better-structured market on top of distributed ledger and smart contract.</p><p>Come and build with us at INTROSPECT.</p><p><strong>LAYER 4: ECONOMICAL AND POLITICAL LAYER</strong></p><p>As a distributed system, bitcoin and Ethereum is still controlled by that 1 percent of people on the planet. Let me explain the web of finance to you and how our foundation is trying to decentralize finance not just from the view of technology but also from the economical and political layers.</p><p>I hope everyone has heard about ICOs (initial coin offerings ) in the ICOs of the biggest layer 1 ecosystem and users building on top of them. I will name a few. Ethereum, Polygon, and Solana are participated by various big institutional investors and VCs. So how the VCs ecosystem works is that they take Assets under Management from big investors and family offices run by always rich families for ages. Thus they promise them a return of around 8–10% besides charging them AUMs fees and thus if you invest a billion dollars being a wealthy family &amp; get $100M a year from different VCs, that’s enough I guess, even if you burn cash in the house chimney. You are not able to burn that lot of cash. The point is that we think we are distributing wealth by building on top of distributed technologies but that’s just an illusion.</p><p>Though ICOs should not be leveraged and open for everyone to buy in abundance using economical power thus in an equitable way. The same thing we did. We got approached by Dubai family offices wanting to invest in WEU Foundation after (6–7 meetings ) but we had to decline as we don’t want to centralize the foundation thus anyone owning it. Though we got an offer of (20M$) &amp; I would have run the foundation easily &amp; it would have been built till now but we don’t rely upon changing our vision and that’s our main component.</p><p>Being a founder, I always emphasize the spirit of everyone being a founder here, not labor. If you have not felt like working in a labor environment created in this world, please do work. You will find everyone working for their profit and that of their investors. Here we believe to build a distributed and equitable world. A sharable foundation where we lay the next foundation of finance and technology.</p><p><strong>LAYER 5: PHILOSOPHICAL &amp; CONSENSUS LAYER</strong></p><p>Why does everything on this planet run on philosophy and Consensus?</p><p>Just because we think there is a superior entity. I will not go into it. But will give you a real-life example. You see Hitler who by his actions killed 60,00,000 people that’s a hell lot number. It’s just he didn’t kill with his gun, it’s just the belief and hatred towards a particular community that made him do it, But if you see his army, they don’t have their brains. They don’t have humanity. Only they are bound by rules. So does everyone right now. It’s just these few people structuralized it in a civilized way. Thus everyone is still the puppet of these big techs and corporates by putting economical constraints as they can print unlimited until you are agreeing with them.</p><p>At that time Nazis were doing WW2. So there is no difference as I feel the world will keep turning into a greedy and selfish world until we take a step.</p><p>As you see we access Web3 from our Web2 IP address hosted by centralized parties &amp; thus few people are sitting in the cabinets which is a government &amp; making decisions to let us restrict our access to the decentralized web 🕸️. People like to work in a centralized environment and tend to neglect a decentralized environment where everyone can thrive.</p><p>I will end up here as everyone has their brain and thinking capacity.</p><p>And remember, the world runs out of consensus (agreement). The moment we all take a step, the world will change in front of our eyes.</p><p>Join us,Join within</p><p><strong>WEU FOUNDATION</strong></p><p>World’s most Decentralized foundation to work and thrive.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a311a48f61b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A short brief story from distributed to a truthful systems and new middleware for staking eth in a…]]></title>
            <link>https://weufoundation.medium.com/a-short-brief-story-from-distributed-to-a-truthful-systems-and-new-middleware-for-staking-eth-in-a-48d2bd9b11f5?source=rss-b9cf26a7e25b------2</link>
            <guid isPermaLink="false">https://medium.com/p/48d2bd9b11f5</guid>
            <category><![CDATA[staking]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[dlt]]></category>
            <category><![CDATA[bitcoin]]></category>
            <dc:creator><![CDATA[WEU FOUNDATION]]></dc:creator>
            <pubDate>Wed, 04 Jan 2023 13:28:31 GMT</pubDate>
            <atom:updated>2023-01-04T16:33:45.348Z</atom:updated>
            <content:encoded><![CDATA[<h3>A short brief story from distributed to a truthful systems and new middleware to staking eth in a new way</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eKhv4bH6OjC5tT1qY3yujQ.png" /></figure><p>Bitcoin was our 0 to 1 for trustless applications. Ethereum for trustless computing. <br>And soon, the eigenlayer will extend $ETH to provide generic, extendable trust. Bitcoin invented decentralized computation: the coordination of untrusted computers to achieve a unified computing environment.<br>However, Bitcoin was implemented as an application-specific blockchain computer. Its only function is to transfer $BTC.<br>To create any other application/functionality, you would have to deploy a new network with a new basis of decentralized trust. <br>Each application would fracture the available trust further and further.<br>Ethereum replaces Bitcoin’s application-specific computing environment with a generalized one.<br>Bitcoin can only add or subtract. Ethereum is Turing-complete.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4oBfdAn5bKYmGRoFH87MWg.jpeg" /></figure><p>Turing-completeness is a concept that boils down to “if a system is Turing-complete it can do anything that any other Turing-complete system can do”.</p><p>We can prove that @ethereum is Turing-complete and therefore we know it is capable of everything your Macbook is capable of.</p><p>Check out more details about turing complete here</p><h3>Tyrannosaurus Haym on Twitter: &quot;(1/21) Computer Science Fundamentals: Turing Machines and Turing Completeness.Want to learn just how powerful @ethereum really is? You need to understand this core concept! / Twitter&quot;</h3><p>(1/21) Computer Science Fundamentals: Turing Machines and Turing Completeness.Want to learn just how powerful @ethereum really is? You need to understand this core concept!</p><p>Ethereum allows a developer to deploy a decentralized application without having to build out a decentralized trust network. <br>Decentralized trust becomes a resource supplied by Ethereum. All the technology, infrastructure, and participants get abstracted away.<br>From the perspective of an application, Ethereum provides a decentralized trust module. Developers are freed up for innovation. <br>Before they had to rebuild the wheel and nurture a network before they even got started. Today all that comes in the base package.<br>However, Ethereum didn’t solve the trust problem. The trust module is built on the first three layers of the system (trust, consensus, and context).<br>This created a great platform for innovation but requires a complete rebuild for changes to those 3 layers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ItJ8u2oFqon50AxoXrHyA.jpeg" /></figure><p>Turns out Ethereum only provides trust around block production, but there are lots of other applications that need trust.<br>Any other trust we must supply directly through Middleware.<br>Middleware is any software that provides a service, information, or method of communication between chains. <br>Middleware exists between chains and therefore must secure its trust. A good example of middleware is oracles, software that transfers data in and out of the Ethereum computing environment.<br>These protocols must bootstrap their trust network… which is very hard and expensive. There’s a reason why <a href="http://twitter.com/chainlink">@chainlink</a> is the only game in town.</p><p>Here learn what oracles are and how they work as a middleware for providing data in and out in various layers of Blockchains.</p><h3>Tyrannosaurus Haym on Twitter: &quot;(1/20) @ethereum, Oracles and @chainlink: The Communication Layer of Web3How do smart contracts get info from outside the Ethereum blockchain? How can a protocol interact with a web2 service? How will The World Computer integrate with The Real World?This thread has answers! pic.twitter.com/ZNfCQpAjhW / Twitter&quot;</h3><p>(1/20) @ethereum, Oracles and @chainlink: The Communication Layer of Web3How do smart contracts get info from outside the Ethereum blockchain? How can a protocol interact with a web2 service? How will The World Computer integrate with The Real World?This thread has answers! pic.twitter.com/ZNfCQpAjhW</p><p>Eigenlayer integrates at the node level of Ethereum. Nodes are where $ETH staking takes place.<br>Node operators lock $ETH in exchange for the right to operate a node. If the operator behaves and fulfills his duties, he earns $ETH.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K_5QnRuI4ezej-AopLCmjQ.jpeg" /></figure><p>If he fails in his duty (or worse, takes malicious action), a portion of the $ETH that he locked up is slashed (permanently taken) and they are ejected from the network. <br>This is the mechanism by which Ethereum secures and delivers trust. And so, a node operator puts capital at stake and operates a node. <br>Nodes are real computers scattered across the globe. The requirements for running an Ethereum node are EXTREMELY low, especially considering the capital at stake. Requirements are kept low deliberately; every person, whether MEGACORP CEO or Aunt Phillis, can become a node operator and keep the network honest.<br>From decentralization flows credible neutrality. <br>From credible neutrality comes global dominance.<br>Here learn about how the credibility of the nodes in the network.</p><h3>Tyrannosaurus Haym on Twitter: &quot;(17/24) Requirements are kept low deliberately; every person, whether MEGACORP CEO or Aunt Phillis, can become a node operator and keep the network honest.From decentralization flows credible neutrality. From credibly neutrality comes global dominance. https://t.co/BaXMiDjgcq / Twitter&quot;</h3><p>(17/24) Requirements are kept low deliberately; every person, whether MEGACORP CEO or Aunt Phillis, can become a node operator and keep the network honest.From decentralization flows credible neutrality. From credibly neutrality comes global dominance. https://t.co/BaXMiDjgcq</p><p>Many node operators have extra computational power, some MUCH more.<br>Eigenlayer allows node operators to deploy their excess computing power for middleware layers while tapping into the trust base of Ethereum.<br>The process is called restaking.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dK2_U1W27JozzTj-o0QMFQ.jpeg" /></figure><p>Node operators begin the process like normal, locking $ETH in exchange for the right to operate a node.<br>Then node operators opt-in to being a service provider for <a href="http://twitter.com/eigenlayer">@eigenlayer</a>.Restaking means your $ETH is put at risk for additional slashing if the node operates misbehaves in providing these additional services <br>This isn’t a liquid staking product, this is managed through the delegated withdrawal address$ETH stakers can set the withdrawal address of their node to a 3rd party address. When they opt-in to eigenlayer, they set their withdrawal address to an EigenLayr smart contract. This contract can then deduct any $ETH before returning it to you (effectively slashing).In exchange for committing to operate the middleware and taking this extra risk, the node operator is compensated by the service provider. <br>Thus, the middleware can tap directly into $ETH’s trust baseMerge mining refers to the act of mining two or more cryptocurrencies at the same time, without sacrificing overall mining performance.<br>Restaking is Proof of Stake’s version: merge staking.<br>Below is <a href="http://twitter.com/ethereum">@ethereum</a>’s roadmap. As much as it’s full of detail, it’s even more full of questions.<br>The more I ask, the more I realize I still have to learn. <br>And the more I realize that Ethereum is inevitable.</p><h3>Tyrannosaurus Haym on Twitter: &quot;(1/27) @ethereum RoadmapIn ~24 hours, Ethereum be changed forever. But The Merge is not the end, it simply marks a new chapter; one with many more improvements. Ethereum is becoming the World Computer!A guide to the plan that will take Ethereum from 12 to 100,000 txns/sec. pic.twitter.com/mqdwbTNezr / Twitter&quot;</h3><p>(1/27) @ethereum RoadmapIn ~24 hours, Ethereum be changed forever. But The Merge is not the end, it simply marks a new chapter; one with many more improvements. Ethereum is becoming the World Computer!A guide to the plan that will take Ethereum from 12 to 100,000 txns/sec. pic.twitter.com/mqdwbTNezr</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48d2bd9b11f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>