<?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 Kyle Charbonnet on Medium]]></title>
        <description><![CDATA[Stories by Kyle Charbonnet on Medium]]></description>
        <link>https://medium.com/@kylecharbonnet?source=rss-541bf8203afe------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GZwTN39WoBr2GraMbQ3Ncg.png</url>
            <title>Stories by Kyle Charbonnet on Medium</title>
            <link>https://medium.com/@kylecharbonnet?source=rss-541bf8203afe------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 16:32:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kylecharbonnet/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[A Technical Introduction to MACI 1.0]]></title>
            <link>https://medium.com/privacy-scaling-explorations/a-technical-introduction-to-maci-1-0-db95c3a9439a?source=rss-541bf8203afe------2</link>
            <guid isPermaLink="false">https://medium.com/p/db95c3a9439a</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[zero-knowledge-proofs]]></category>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[voting]]></category>
            <dc:creator><![CDATA[Kyle Charbonnet]]></dc:creator>
            <pubDate>Tue, 18 Jan 2022 15:11:01 GMT</pubDate>
            <atom:updated>2022-01-18T15:11:01.693Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aWsBozO7zkpxbwpH.png" /></figure><ol><li><a href="#5e4c">Introduction</a><br>a. <a href="#2bcd">Background</a></li><li><a href="#6ca2">System Overview<br></a>a. <a href="#f130">Roles</a><br>b. <a href="#0b6f">Vote Overriding and Public Key Switching</a><br>c. <a href="#aa08">zk-SNARKs</a></li><li><a href="#357c">Workflow</a><br>a. <a href="#a35f">Sign Up</a><br>b. <a href="#37df">Publish Message</a><br>c. <a href="#493a">Process Messages</a><br>d. <a href="#56b5">Tally Votes</a></li><li><a href="#53c9">Conclusion</a></li></ol><h3>1. Introduction</h3><p>MACI, which stands for Minimal Anti-Collusion Infrastructure, is an application that allows users to have an on-chain voting process with greatly increased collusion resistance. A common problem among today’s on-chain voting processes is how easy it is to bribe voters into voting for a particular option. Oftentimes this bribery takes the form of “join our pool (vote our way) and we will give you a cut of the rewards (the bribe)”. Since all transactions on the blockchain are public, without MACI, voters can easily prove to the briber which option they voted for and therefore receive the bribe rewards.</p><p>MACI counters this by using zk-SNARKs to essentially hide how each person voted while still revealing the final vote result. User’s cannot prove which option they voted for, and therefore bribers cannot reliably trust that a user voted for their preferred option. For example, a voter can tell a briber that they are voting for option A, but in reality they voted for option B. There is no reliable way to prove which option the voter actually voted for, so the briber does not have the incentive to pay voters to vote their way.</p><h3>a. Background</h3><p>For a general overview, the history and the importance of MACI, see <a href="https://medium.com/privacy-scaling-explorations/release-announcement-maci-1-0-c032bddd2157">Release Announcement: MACI 1.0</a> by Wei Jie, one of the creators. He also created a very helpful <a href="https://www.youtube.com/watch?v=sKuNj_IQVYI">youtube video</a> on the overview of MACI. To see the origin of the idea of MACI, see Vitalik’s research post on <a href="https://ethresear.ch/t/minimal-anti-collusion-infrastructure/5413?u=weijiekoh">Minimal Anti-Collusion Infrastructure</a>. Lastly, it is recommended to understand the basic idea behind zk-SNARKs, as these are a core component of MACI. The following articles are great resources:</p><ul><li><a href="https://consensys.net/blog/developers/introduction-to-zk-snarks/">Introduction to zk-SNARKs</a> — Consensys</li><li><a href="https://z.cash/technology/zksnarks/">What are zk-SNARKs</a> — Zcash</li><li><a href="https://vitalik.ca/general/2021/01/26/snarks.html">An approximate introduction to how zk-SNARKs are possible</a> — Vitalik</li><li><a href="https://blog.ethereum.org/2016/12/05/zksnarks-in-a-nutshell/">zkSNARKs in a nutshell</a> — Ethereum.org</li></ul><p>This article will go over the general workflow of MACI and how it is capable of providing the following tenets (taken word for word from Wei Jie’s article):</p><ol><li><strong>Collusion Resistance</strong>: No one except a trusted coordinator should be certain of the validity of a vote, reducing the effectiveness of bribery</li><li><strong>Receipt-freeness</strong>: No voter may prove (besides to the coordinator) which way they voted</li><li><strong>Privacy</strong>: No one except a trusted coordinator should be able to decrypt a vote</li><li><strong>Uncensorability</strong>: No one (not even the trusted coordinator) should be able to censor a vote</li><li><strong>Unforgeability</strong>: Only the owner of a user’s private key may cast a vote tied to its corresponding public key</li><li><strong>Non-repudiation</strong>: No one may modify or delete a vote after it is cast, although a user may cast another vote to nullify it</li><li><strong>Correct execution</strong>: No one (not even the trusted coordinator) should be able to produce a false tally of votes</li></ol><h3>2. System Overview</h3><h3>a. Roles</h3><p>In the MACI workflow, there are two different roles: users (voters) and a single trusted coordinator. The users vote on the blockchain via MACI smart contracts, and the coordinator tallies up the votes and releases the final results.</p><p>The coordinators must use zk-SNARKs to prove that their final tally result is valid without releasing the vote of every individual. Therefore, even if a coordinator is corrupt, they are unable to change a user’s vote or add extra votes themselves. A corrupt coordinator can stop a vote by never publishing the results, but they can’t publish false results.</p><p>Before sending their vote on the blockchain, users encrypt their vote using a shared key that only the user and coordinator can know. This key scheme is designed so that every individual user shares a distinct key with the coordinator. This prevents any bribers from simply reading the transaction data to see which option a user voted for. The encrypted vote is now considered a “message” and the user sends this message to a MACI smart contract to be stored on-chain.</p><p>A very simplified illustration of this encryption can be seen below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tJ-W98tt7Q0ZgEUF" /></figure><h3>b. Vote Overriding and Public Key Switching</h3><p>Before a user can cast a vote, they must sign up by sending the public key they wish to use to vote to a MACI smart contract. This public key acts as their identity when voting. They can vote from any address, but their message must contain a signature from that public key. When casting an actual vote after signing up, a user will bundle a few variables — including a public key, their vote option, their vote amount, and a few others — into what is called a “command”. Then, the user signs the command with the public key they originally used to sign up. After that, the user encrypts the signature and command together so that it is now considered a message. This more complex description of how a message is constructed is illustrated below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*whHfC8-xxAwSyaaO" /></figure><p>Users are able to override their previous vote as long as they sign their command with the previous public key. If the command is properly signed by the user’s previous public key, then the message is considered valid and the coordinator will count this as the correct vote. So, when a user provides a public key in their vote that is different than their previous public key, they may now submit a new vote signed by this new public key to override their previous vote. If the signature is not from the previous public key, the message will be marked as invalid and not counted toward the tally. Therefore, the public key can be thought of as the user’s voting username, and the signature is the voting password. If they provide the correct signature, they can submit a vote or change their public key — or both.</p><p>This feature, which I refer to as public key switching, is designed to counter the bribery attack where a user simply shows the briber their message, and then decrypts it for the briber to see which way the user voted. Public key switching allows users to change their public key and create invalid messages in favor of the bribers. The bribers have no way of telling if the user switched their public keys before sending in the vote shown to the bribers.</p><p>This can be quite confusing so here is an example:</p><ol><li>Bob signs up with public key 1</li><li>Bob then creates a command that contains — a vote for option A and public key 2</li><li>Bob signs this command with public key 1, the key he used to sign up</li><li>Bob encrypts this command into a message and submits it to the MACI smart contracts</li><li>The coordinator decrypts this message, and checks to ensure that the command is signed by Bob’s previous key — public key 1. This message is valid.</li><li>The coordinator then records Bob’s vote for option A and updates his public key to public key 2</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*t3CAiLfDniv2fkYI" /></figure><p>At this point, Bob has successfully voted for option A, and in order to override this vote must send in a new vote with a signature from public key 2. At this point, a briber now tries to get Bob to vote for option B:</p><ol><li>Bob creates a command that contains — a vote for option B and public key 1</li><li>Bob signs this command with public key 1, encrypts the message and submits it to the MACI smart contracts</li><li>Bob shows the briber the decrypted message as proof of his vote for option B</li><li>The coordinator decrypts Bob’s message and sees that the signature does not match up with public key 2 — Bob’s previous key added in his previous message. Therefore this message is invalid and this vote is not counted in the final tally.</li><li>The briber has no way of knowing whether the vote was valid or invalid, and so is not incentivized to offer bribes to other users.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tqKB8TxOQj27IVS3" /></figure><p>In order to get a good idea of how MACI works, it’s important to know how the zk-SNARKs are able to prove that the coordinator decrypted each message and tallied the votes properly. The next section gives a quick and much oversimplified overview of zk-SNARKs, although the readings listed in the introduction are much more helpful.</p><h3>c. zk-SNARKs</h3><p>Essentially, zk-SNARKs allow users to prove they know an answer to a specific mathematical equation, without revealing what that answer is. Take the following equation for example,</p><blockquote>X + Y = 15</blockquote><p>I can prove that I know 2 values, X and Y that satisfy the equation without revealing what those two values are. When I create a zk-SNARK for my answer, anyone can use the SNARK (a group of numbers) and validate it against the equation above to prove that I do know a solution to that equation. The user is unable to use the SNARK to find out my answers for X and Y.</p><p>For MACI, the equation is much more complicated but can be summarized as the following equations:</p><blockquote>encrypt(command1) = message1</blockquote><blockquote>encrypt(command2) = message2</blockquote><blockquote>encrypt(command3) = message3</blockquote><blockquote>…</blockquote><blockquote>Command1 from user1 + command2 from user2 + command3 from user3 + … = total tally result</blockquote><p>Here, everyone is able to see the messages on the blockchain and the total tally result. Only the coordinator knows what the individual commands/votes are by decrypting the messages. So, the coordinator uses a zk-SNARK to prove they know all of the votes that:</p><ol><li>Encrypt to the messages present on the blockchain</li><li>Sum to the tally result</li></ol><p>Users can then use the SNARK to prove that the tally result is correct, but cannot use it to prove any individual’s vote choices.</p><p>Now that the core components of MACI have been covered, it is helpful to dive deeper into the MACI workflow and specific smart contracts.</p><h3>3. Workflow</h3><p>The general workflow process can be broken down into 4 different phases:</p><ol><li>Sign Up</li><li>Publish Message</li><li>Process Messages</li><li>Tally Results</li></ol><p>These phases make use of 3 main smart contracts — MACI, Poll and ​​PollProcessorAndTallyer. These contracts can be found on the <a href="https://github.com/appliedzkp/maci/tree/v1/contracts/contracts">MACI github page</a>. The MACI contract is responsible for keeping track of all the user sign ups by recording the initial public key for each user. When a vote is going to take place, users can deploy a Poll smart contract via MACI.deployPoll().</p><p>The Poll smart contract is where users submit their messages. One MACI contract can be used for multiple polls. In other words, the users that signed up to the MACI contract can vote on multiple issues, with each issue represented by a distinct Poll contract.</p><p>Finally, the PollProcessorAndTallyer contract is used by the coordinator to prove on-chain that they are correctly tallying each vote. This process is explained in more detail in the Process Messages and Tally Results sections below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NA8cwQvAhZoX7Pia" /></figure><h3>a. Sign Up</h3><p>The sign up process for MACI is handled via the MACI.sol smart contract. Users need to send three pieces of information when calling MACI.signUp():</p><ol><li>Public Key</li><li>Sign Up Gatekeeper Data</li><li>Initial Voice Credit Proxy Data</li></ol><p>The public key is the original public key mentioned in above sections that the user will need to vote. As explained in earlier sections, they can change this public key later once voting starts. The user’s public key used to sign up is shared amongst every poll.</p><p>MACI allows the contract creator/owner to set a “signUpGateKeeper”. The sign up gatekeeper is meant to be the address of another smart contract that determines the rules to sign up. So, when a user calls MACI.signUp(), the function will call the sign up gatekeeper to check if this user is valid to sign up.</p><p>MACI also allows the contract creator/owner to set an “initialVoiceCreditProxy”. This represents the contract that determines how many votes a given user gets. So, when a user calls MACI.signUp(), the function will call the initial voice credit proxy to check how many votes they can spend. The user’s voice credit balance is reset to this number for every new poll.</p><p>Once MACI has checked that the user is valid and retrieved how many voice credits they have, MACI stores the following user info into the Sign Up Merkle Tree:</p><ol><li>Public Key</li><li>Voice Credits</li><li>Timestamp</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*h6otS_gfiZ2Wjvoq" /></figure><h3>b. Publish Message</h3><p>Once it is time to vote, the MACI creator/owner will deploy a Poll smart contract. Then, users will call Poll.publishMessage() and send the following data:</p><ol><li>Message</li><li>Encryption Key</li></ol><p>As explained in sections above, the coordinator will need to use the encryption key in order to derive a shared key. The coordinator can then use the shared key to decrypt the message into a command, which contains the vote.</p><p>Once a user publishes their message, the Poll contract will store the message and encryption key into the Message Merkle Tree.</p><h3>c. Process Messages</h3><p>Once the voting is done for a specific poll, the coordinator will use the PollProcessAndTallyer contract to first prove that they have correctly decrypted each message and applied them to correctly create an updated state tree. This state tree keeps an account of all the valid votes that should be counted. So, when processing the messages, the coordinator will not keep messages that are later overridden by a newer message inside the state tree. For example, if a user votes for option A, but then later sends a new message to vote for option B, the coordinator will only count the vote for option B.</p><p>The coordinator must process messages in groups so that proving on chain does not exceed the data limit. The coordinator then creates a zk-SNARK proving their state tree correctly contains only the valid messages. Once the proof is ready, the coordinator calls PollProcessorAndTallyer.processMessages(), providing a hash of the state tree and the zk-SNARK proof as an input parameters.</p><p>The PollProcessorAndTallyer contract will send the proof to a separate verifier contract. The verifier contract is specifically built to read MACI zk-SNARK proofs and tell if they are valid or not. So, if the verifier contract returns true, then everyone can see on-chain that the coordinator correctly processed that batch of messages. The coordinator repeats this process until all messages have been processed.</p><h3>d. Tally Votes</h3><p>Finally, once all messages have been processed, the coordinator tallies the votes of the valid messages. The coordinator creates a zk-SNARK proving that the valid messages in the state tree (proved in Process Messages step) contain votes that sum to the given tally result. Then, they call PollProcessorAndTallyer.tallyVotes() with a hash of the correct tally results and the zk-SNARK proof. Similarly to the processMessages function, the tallyVotes function will send the proof to a verifier contract to ensure that it is valid.</p><p>The tallyVotes function is only successful if the verifier contract returns that the proof is valid. Therefore, once the tallyVotes function succeeds, users can trust that the coordinator has correctly tallied all of the valid votes. After this step, anyone can see the final tally results and the proof that these results are a correct result of the messages sent to the Poll contract. The users won’t be able to see how any individual voted, but will be able to trust that these votes were properly processed and counted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7Le2odbX7e2etpxR" /></figure><h3>4. Conclusion</h3><p>MACI is a huge step forward in preventing collusion for on-chain votes. While it doesn’t prevent all possibilities of collusion, it does make it much harder. MACI can already be <a href="https://twitter.com/vitalikbuterin/status/1329012998585733120">seen</a> to be in use by the <a href="https://blog.clr.fund/round-4-review/">clr.fund</a>, which has users vote on which projects to receive funding. When the possible funding amount becomes very large, users and organizations have a large incentive to collude to receive parts of these funds. This is where MACI can truly make a difference, to protect the fairness of such important voting processes such as those at clr.fund.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db95c3a9439a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/privacy-scaling-explorations/a-technical-introduction-to-maci-1-0-db95c3a9439a">A Technical Introduction to MACI 1.0</a> was originally published in <a href="https://medium.com/privacy-scaling-explorations">Privacy &amp; Scaling Explorations</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Technical Introduction to Arbitrum’s Optimistic Rollup]]></title>
            <link>https://medium.com/privacy-scaling-explorations/a-technical-introduction-to-arbitrums-optimistic-rollup-860955ea5fec?source=rss-541bf8203afe------2</link>
            <guid isPermaLink="false">https://medium.com/p/860955ea5fec</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[optimistic-rollup]]></category>
            <category><![CDATA[rollup]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Kyle Charbonnet]]></dc:creator>
            <pubDate>Thu, 30 Sep 2021 10:12:18 GMT</pubDate>
            <atom:updated>2021-11-01T22:54:57.007Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/696/1*6CesZrI_Az8ZQ3Zff0y6gw.png" /></figure><p>Arbitrum is Offchain Labs’ optimistic rollup implementation that aims to greatly increase the throughput of the Ethereum network. This guide is an introduction to how the Arbitrum design works and is meant for anyone looking to get a somewhat technical overview on this layer 2 solution. This article assumes that the reader has some knowledge of Ethereum and optimistic rollups. The following links may be helpful to those who would like more info on optimistic rollups:</p><ol><li><a href="https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/optimistic_rollups/">Optimistic Rollups</a></li><li><a href="https://vitalik.ca/general/2021/01/05/rollup.html">An Incomplete Guide to Rollups</a></li><li><a href="https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698">A Rollup-Centric Ethereum Roadmap</a></li><li><a href="https://research.paradigm.xyz/rollups">(Almost) Everything you need to know about the Optimistic Rollup</a></li></ol><p>The Arbitrum network is run by two main types of nodes — batchers and validators. Together these nodes interact with Ethereum mainnet (layer 1, L1) in order to maintain a separate chain with its own state, known as layer 2 (L2). Batchers are responsible for taking user L2 transactions and submitting the transaction data onto L1. Validators on the other hand, are responsible for reading the transaction data on L1, processing the transaction and therefore updating the L2 state. Validators will then post the updated L2 state data to L1 so that anyone can verify the validity of this new state. The transaction and state data that is actually stored on L1 is described in more detail in the ‘Transaction and State Data Storage on L1’ section.</p><p><strong>Basic Workflow</strong></p><ol><li>The basic workflow begins with users sending L2 transactions to a batcher node, usually the sequencer.</li><li>Once the sequencer receives enough transactions, it will post them into an L1 smart contract as a batch.</li><li>A validator node will read these transactions from the L1 smart contract and process them on their local copy of the L2 state.</li><li>Once processed, a new L2 state is generated locally and the validator will post this new state root into an L1 smart contract.</li><li>Then, all other validators will process the same transactions on their local copies of the L2 state.</li><li>They will compare their resultant L2 state root with the original one posted to the L1 smart contract.</li><li>If one of the validators gets a different state root than the one posted to L1, they will begin a challenge on L1 (explained in more detail in the ‘Challenges’ section).</li><li>The challenge will require the challenger and the validator that posted the original state root to take turns proving what the correct state root should be.</li><li>Whichever user loses the challenge, gets their initial deposit (stake) slashed. If the original L2 state root posted was invalid, it will be destroyed by future validators and will not be included in the L2 chain.</li></ol><p>The following diagram illustrates this basic workflow for steps 1–6.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EQPPvkcBlIBmDD6I" /></figure><h3>Batcher Nodes and Submitting L2 Transaction Data</h3><p>There are two different L1 smart contracts that batcher nodes will use to post the transaction data. One is known as the ‘delayed inbox’ while the other is known as the ‘sequencer inbox’. Anyone can send transactions to the delayed inbox, whereas only the sequencer can send transactions to the sequencer inbox. The sequencer inbox pulls in transaction data from the delayed inbox and interweaves it with the other L2 transactions submitted by the sequencer. Therefore, the sequencer inbox is the primary contract where every validator pulls in the latest L2 transaction data.</p><p>There are 3 types of batcher nodes — forwarders, aggregators, and sequencers. Users can send their L2 transactions to any of these 3 nodes. Forwarder nodes forward any L2 transactions to a designated address of another node. The designated node can be either a sequencer or an aggregator and is referred to as the aggregator address.</p><p>Aggregator nodes will take a group of incoming L2 transactions and batch them into a single message to the delayed inbox. The sequencer node will also take a group of incoming L2 transactions and batch them into a single message, but it will send the batch message to the sequencer inbox instead. If the sequencer node stops adding transactions to the sequencer inbox, anyone can force the sequencer inbox to include transactions from the delayed inbox via a smart contract function call. This allows the Arbitrum network to always be available and resistant to a malicious sequencer. Currently Arbitrum is running their own single sequencer for Arbitrum mainnet, but they have plans to decentralize the sequencer role in the future.</p><p>The different L2 transaction paths are shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SnCy99ibeKg5ACA2" /></figure><p>Essentially, batcher nodes are responsible for submitting any L2 transaction data onto L1. Once these transactions are processed on L2 and a new state is generated, a validator must submit that state data onto L1 as well. That process is covered in the next section.</p><h3>Validator Nodes and Submitting L2 State Data</h3><p>The set of smart contracts that enable validators to submit and store L2 state data is known as the rollup. The rollup is essentially a chain of blocks, so in other words, the rollup is the L2 chain. Note that the Arbitrum codebase refers to these blocks as ‘nodes’. However, to prevent confusion with the terms ‘validator nodes’ and ‘batcher nodes’, I will continue to refer to these rollup nodes as blocks throughout the article.</p><p>Each block contains a hash of the L2 state data. So, validators will read and process transactions from the sequencer inbox, and then submit the updated L2 state data hash to the rollup smart contract. The rollup, which stores a chain of blocks, will create a new block with this data and add it as the latest block to the chain. When the validator submits the L2 state data to the rollup smart contract, they also specify which block in the current chain is the parent block to this new block.</p><p>In order to penalize validators that submit invalid state data, a staking system has been implemented. In order to submit new L2 state data to the rollup, a validator must be a staker — they must have deposited a certain amount of Eth (or other tokens depending on the rollup). That way, if a malicious validator submits invalid state data, another validator can challenge that block and the malicious validator will lose their stake.</p><p>Once a validator becomes a staker, they can then stake on different blocks. Here are some of the important rules to staking:</p><ul><li>Stakers must stake on any block they create.</li><li>Multiple stakers can stake on the same block.</li><li>Stakers cannot stake on two separate block paths — when a staker stakes on a new block, it must be a descendant of the block they were previously staked on (unless this is the stakers first stake).</li><li>Stakers do not have to add an additional deposit anytime they stake on a new block.</li><li>If a block loses a challenge, all stakers staked on that block or any descendant of that block will lose their stake.</li></ul><p>A block will be confirmed — permanently accepted in L1 and never reverted — if all of the following are true:</p><ul><li>The 7 day period has passed since the block’s creation</li><li>There are no existing challenging blocks</li><li>At least one staker is staked on it</li></ul><p>A block can be rejected (destroyed) if all of the following are true:</p><ul><li>It’s parent block is older than the latest confirmed block (the latest confirmed block is on another branch)</li><li>There is a staker staked on a sibling block</li><li>There are no stakers staked on this block</li><li>The 7 day period has passed since the block’s creation</li></ul><p>Take the following diagram as an example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IqVGQClE2jh3_he2h03Y6g.png" /></figure><p>In this example, since blocks 4 and 5 share the same parent, staker 5 decides to challenge staker 4 and wins since block 4 contains invalid state data. Therefore, both staker 4 and staker 6 will lose their stakes. Stakers will continue adding new blocks to the chain that contains blocks 5 and 7. Blocks 4 and 6 will then be destroyed after the 7 day period has passed. Even though stakers are necessary for the system to work, not all validator nodes are stakers. The different types of validators are explained in the next section.</p><p><strong>Validator Types</strong></p><p>Each validator may use a different strategy to keep the network secure. Currently, there are three types of supported validating strategies — Defensive, StakeLatest, and MakeBlocks (known as MakeNodes in the codebase). Defensive validators will monitor the rollup chain of blocks and look out for any forks/conflicting blocks. If a fork is detected, that validator will switch to the StakeLatest strategy. Therefore, if there are no conflicting blocks, defensive validators will not have any stakes.</p><p>StakeLatest validators will stake on the existing blocks in the rollup if the blocks have valid L2 state data. They will advance their stake to the furthest correct block in the chain as possible. StakeLatest validators normally do not create new blocks unless they have identified a block with incorrect state data. In that case, the validators will create a new block with correct data and mandatorily stake on it.</p><p>MakeBlocks validators will stake on the furthest correct block in the rollup chain as well. However, even when there are no invalid blocks, MakeBlocks validators will create new blocks once they have advanced their stake to the end of the chain. These are the primary validators responsible for progressing the chain forward with new state data.</p><p>The following diagram illustrates the actions of the different validator strategies:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YbTcGT7GgwId0XYdKLNHiA.png" /></figure><h3>Transaction and State Data Storage on L1</h3><p><strong>Transaction Data Storage</strong></p><p>As explained above, aggregator and sequencer nodes receive L2 transactions and submit them to the L1 delayed and sequencer inboxes. Posting this data to L1 is where most of the expenses of L2 come from. Therefore, it is important to understand how this data is stored on L1 and the methods used to reduce this storage requirement as much as possible.</p><p>Aggregator nodes receive user L2 transactions, compress the calldata into a byte array, and then combine multiple of these compressed transactions into an array of byte arrays known as a transaction batch. Finally, they will submit the transaction batch to the delayed inbox. The inbox will then hash the transaction batch and store the hash in contract storage. Sequencer nodes follow a very similar pattern, but the sequencer inbox must also include data about the number of messages to include from the delayed inbox. This data will be part of the final hash that the sequencer inbox stores in contract storage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R-ib5WR8-cEm3AAy" /></figure><p><strong>State Data Storage</strong></p><p>After MakeBlocks validators read and process L2 transactions from the sequencer inbox, they will submit their updated L2 state data to the rollup smart contract. The rollup smart contract then hashes the state data and stores the hash in contract storage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W4AcHZLDfTOfUh2IJmuk5A.png" /></figure><p><strong>Retrieving Transaction and State Data</strong></p><p>Even though only the hash of the transaction and state data is stored in contract storage, other nodes can see the original data by retrieving the calldata of the transaction that submitted the data to L1 from an Ethereum full node. The calldata of transactions to the delayed or sequencer inboxes contain the data for every L2 transaction that the aggregator or sequencer batched. The calldata of transactions to the rollup contract contain all of the relevant state data — enough for other validators to determine if it is valid or invalid — for L2 at that time. To make looking up the transaction easier, the smart contracts emit an event to the Ethereum logs that allows anyone to easily search for either the L2 transaction data or the L2 state data.</p><p>Since the smart contracts only have to store hashes in their storage rather than the full transaction or state data, a lot of gas is saved. The primary cost of rollups comes from storing this data on L1. Therefore, this storage mechanism is able to reduce gas expenses even further.</p><h3>The AVM and ArbOS</h3><p><strong>The Arbitrum Virtual Machine</strong></p><p>Since Arbitrum L2 transactions are not executed on L1, they don’t have to follow the same exact rules as the EVM for computation. Therefore, the Arbitrum team built their own virtual machine known as the Arbitrum Virtual Machine (AVM). The AVM is very similar to the EVM because a primary goal was to support compatibility with EVM compiled smart contracts. However, there are a few important differences.</p><p>A major difference between the AVM and EVM is that the AVM must support Arbitrum’s challenges. Challenges, covered in more detail in the next section, require that a step of transaction execution must be provable. Therefore, Arbitrum has introduced the use of CodePoints to their virtual machine. Normally, when code is executed, the instructions are stored in a linear array with a program counter (PC) pointing to the current instruction. Using the program counter to prove which instruction is being executed would take logarithmic time. In order to reduce this time complexity to constant time, the Arbitrum team implemented CodePoints — a pair of the current instruction and the hash of the next codepoint. Every instruction in the array has a codepoint and this allows the AVM to instantly prove which instruction was being executed at that program counter. CodePoints do add some complexity to the AVM, but the Arbitrum system only uses codepoints when it needs to make a proof about transaction execution. Normally, it will use the normal program counter architecture instead.</p><p>There are quite a few other important differences that are well documented on Arbitrum’s site — <a href="https://developer.offchainlabs.com/docs/inside_arbitrum#why-avm-differs-from-evm">Why AVM Differs from EVM</a></p><p><strong>ArbOS</strong></p><p>ArbOS is Arbitrum’s own operating system. It is responsible for managing and tracking the resources of smart contracts used during execution. So, ArbOS keeps an account table that keeps track of the state for each account. Additionally, it operates the funding model for validators participating in the rollup protocol.</p><p>The AVM has built in instructions to aid the execution of ArbOS and its ability to track resources. This support for ArbOS in the AVM allows ArbOS to implement certain rules of execution at layer 2 instead of in the rollup smart contracts on layer 1. Any computation moved from layer 1 to layer 2 saves gas and lowers expenses.</p><h3>Challenges</h3><p>Optimistic rollup designs require there be a way to tell whether the L2 state data submitted to L1 is valid or invalid. Currently, there are two widely known methods — replayability and interactive proving. Arbitrum has implemented interactive proving as their choice for proving an invalid state.</p><p>When a validator submits updated state data to the rollup, any staker can challenge that block and submit the correct version of it. When a challenge begins, the two stakers involved (challenger and challenged staker) must take turns dividing the execution into an equal number of parts and claim which of those parts is invalid. Then they must submit their version of that part. The other staker will then dissect that part into an equal number of parts as well, and select which part they believe is invalid. They will then submit their version of that part.</p><p>This process continues until the contested part of execution is only one instruction long. At this point, the smart contracts on L1 will perform a one step proof. Essentially, the one step proof executes that one instruction and returns an updated state. The block whose state matches that of the one step proof will win the challenge and the other block will lose their stake. The following diagram illustrates an example of a challenge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2FC-gSvb-LD99c6MMv4NEw.png" /></figure><h3>Conclusion</h3><p><strong>How does this raise Ethereum’s transaction per second and lower transaction costs?</strong></p><p>Arbitrum, along with all optimistic rollups, greatly improves the scalability of the Ethereum network and therefore lowers the gas costs (holding throughput constant). In L1 every Ethereum full node in the network will process the transaction, and since the network contains so many nodes, computation becomes very expensive. With Arbitrum, transactions will only be processed by a small set of nodes — the sequencer, aggregators, and validators. So, the computation of each transaction has been moved off of L1 while only the transaction calldata remains on L1. This clears a lot of space on L1 and allows many more transactions to be processed. The greater throughput reduces the gas costs since the competition for getting a transaction added to a block is lower.</p><p><strong>Anything special about Abritrum’s implementation of optimistic rollups?</strong></p><p>Arbitrum’s design gives many advantages that other rollup implementations don’t have because of its use of interactive proving. Interactive proving provides a great number of benefits, such as no limits on contract size, that are outlined in good detail on Arbitrum’s site — <a href="https://developer.offchainlabs.com/docs/inside_arbitrum#why-interactive-proving-is-better">Why Interactive Proving is Better</a>. With Arbitrum’s successful mainnet launch (though still early), it’s clear that the project has achieved an incredible feat.</p><p>If you’re interested in reading more on Arbitrum’s optimistic rollup, their documentation covers a lot more ground and is easy to read.</p><ul><li><a href="https://developer.offchainlabs.com/docs/inside_arbitrum">Arbitrum Doc — Inside Arbitrum</a></li><li><a href="https://developer.offchainlabs.com/docs/rollup_protocol">Arbitrum Doc — Rollup Protocol</a></li><li><a href="https://developer.offchainlabs.com/docs/avm_design">Arbitrum Doc — AVM Design Rationale</a></li><li><a href="https://developer.offchainlabs.com/docs/differences_overview">Arbitrum Doc — Overview of Differences with Ethereum</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=860955ea5fec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/privacy-scaling-explorations/a-technical-introduction-to-arbitrums-optimistic-rollup-860955ea5fec">A Technical Introduction to Arbitrum’s Optimistic Rollup</a> was originally published in <a href="https://medium.com/privacy-scaling-explorations">Privacy &amp; Scaling Explorations</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Introduction to Optimism’s Optimistic Rollup]]></title>
            <link>https://medium.com/privacy-scaling-explorations/an-introduction-to-optimisms-optimistic-rollup-8450f22629e8?source=rss-541bf8203afe------2</link>
            <guid isPermaLink="false">https://medium.com/p/8450f22629e8</guid>
            <category><![CDATA[layer-2]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[guides-and-tutorials]]></category>
            <category><![CDATA[rollup]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Kyle Charbonnet]]></dc:creator>
            <pubDate>Fri, 02 Jul 2021 01:36:32 GMT</pubDate>
            <atom:updated>2022-11-10T22:06:09.922Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X3LDc8uET9CzoK7e5qpcTw.png" /></figure><p><strong>Update 1: </strong>Optimism is currently planning its newest upgrade “Bedrock”. To get a good look and understanding of the changes that will occur, please read <a href="https://hackmd.io/mv0f3MiNSEi271ojKF3t9w">“Optimism Transaction Trails Behind the Scenes, Current Version vs Bedrock”</a> by Yufei Li (L2 Security Engineer at the Ethereum Foundation).</p><p><strong>Update 2</strong>: This article was written mid 2021, and many things have changed in the Optimism codebase. One of the biggest changes since then, is Optimism’s switch from replayable tx fraud proofs to interactive fraud proofs. Please keep in mind that details in this article may be outdated.</p><p>Optimism is a company that has implemented the Optimistic Rollup protocol and aims to greatly increase the throughput of the Ethereum network. This guide is an introduction to how the Optimism design works and is meant for anyone looking to get a brief overview on this layer 2 solution. This article assumes that the reader has some knowledge of Ethereum and optimistic rollups. The following links may be helpful to those who would like more info on optimistic rollups:</p><ol><li><a href="https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/optimistic_rollups/">Optimistic Rollups</a></li><li><a href="https://vitalik.ca/general/2021/01/05/rollup.html">An Incomplete Guide to Rollups</a></li><li><a href="https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698">A Rollup-Centric Ethereum Roadmap</a></li><li><a href="https://research.paradigm.xyz/rollups">(Almost) Everything you need to know about the Optimistic Rollup</a></li></ol><p>Optimism currently has 2 types of nodes — sequencer and verifier (and eventually proposer) — to run its own network. The sequencer and verifier nodes both run L2Geth — a slightly modified version of Geth created by Optimism. Geth is the most popular implementation of the Ethereum protocol. Therefore, the Optimism network is very similar to the Ethereum network but with slight differences explained later on. For the launch of Optimism, there will only be one sequencer node managed by the Optimism team. There are plans to decentralize this role after the launch is stable and secure. For the rest of this article, L1 (layer 1) refers to the Ethereum mainnet chain and L2 (layer 2) refers to the Optimism network chain.</p><p><strong>Basic Workflow</strong></p><ol><li>The basic workflow is that users will send transactions to the sequencer, and the sequencer will process these transactions on its copy of the L2 chain.</li><li>Once processed, the sequencer will submit both the transaction data and the new L2 state root to L1.</li><li>Then, all other L2 nodes mentioned above will process the transaction on their copy of the L2 chain.</li><li>In order to ensure that the new state root submitted to L1 is correct, verifier nodes will compare their new state root to the one submitted by the sequencer.</li><li>If there is a difference, they will begin what’s called a fraud proof. The fraud proof will execute the L2 transaction but on L1 so that the resultant state root cannot be faked.</li><li>If the fraud proof’s resultant state root is different from the one submitted by the sequencer, the sequencer’s initial deposit (known as a bond) will be slashed. The state roots from that transaction onward will be erased and the sequencer will have to recompute those lost state roots correctly this time.</li><li>Once the sequencer role has been decentralized, if the sequencer’s bond gets slashed, a new sequencer will replace it.</li></ol><p>The following diagram illustrates this basic workflow for steps 1–4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ejOc5uwk_edYTciz" /><figcaption>Steps 1–4 of the basic workflow</figcaption></figure><h3>Transactions</h3><p>There are two types of transactions important to this system — L2 transactions that occur between two addresses on the L2 chain and cross chain transactions that occur between the L1 and L2 chains. The following workflow goes into a little more detail than the basic workflow on how L2 transactions work.</p><p><strong>L2 Transaction Workflow</strong></p><ol><li>Users will send transactions to the sequencer node and the sequencer will immediately add it to the L2 chain if it is a valid transaction (Note: at this point, only the sequencer node has added this transaction to its copy of the L2 chain). The block sizes for L2 are 1 transaction only, so immediately a new block is added to the chain with the new transaction. There are no miners competing for mining new blocks in L2 because the sequencer has replaced the miner functionality.</li><li>Then, after the sequencer has added a few transactions to the L2 chain, it will call a smart contract on L1 (deployed by the Optimism team before release) and send it the transaction data for all of those L2 transactions along with the new state roots of the L2 chain after applying each transaction.</li><li>The smart contract on L1 will store the transaction data and state roots in an efficient manner (rollups) in another smart contract designed for storage.</li><li>Once the transaction data has been stored on L1, the verifier nodes will include the transaction in their copies of the L2 chain.</li></ol><p>If the sequencer is censoring a particular user, that user will be able to submit the transaction data and call the smart contract themself. The sequencer will then be forced to process that transaction within a certain time frame. If they don’t, their bond may be slashed.</p><p>Additionally, so far it has been mentioned that the verifier checks the transactions posted to L1 by the sequencer. However, verifiers can also choose to sync from L2, which means that they will get new transactions directly from the sequencer, possibly before they are posted to L1. This sync from L2 method reduces latency, but does not guarantee that the sequencer will post this transaction to L1.</p><p><strong>Cross Chain Transactions</strong></p><p>Cross chain transactions are necessary in this system in order for users to be able to call contracts on other chains or to send ETH/tokens from one chain to another. These transactions have a slightly modified workflow than L2 transactions since they involve both chains.</p><p><strong>L1 -&gt; L2 Transactions</strong></p><p>Transactions from L1 to L2 are quite fast and simply rely on the sequencer to relay the message to the L2 chain. User’s will send their transaction data to a bridge smart contract on L1 and this smart contract will add the transaction to the queue of transactions that the sequencer must add to L2 within a certain time frame. Therefore, the sequencer will eventually relay that transaction to the L2 chain.</p><p>For example, if a user wants to send 10 ETH to their address on L2 so that they can interact with smart contracts on L2, the following steps will happen:</p><ol><li>The user sends 10 ETH to a bridge contract on L1.</li><li>The contract locks the ETH on L1.</li><li>The contract also adds the user’s transaction to the queue of transactions that the sequencer must add to L2.</li><li>The sequencer processes this transaction and the ETH is successfully deposited to the user’s L2 account.</li></ol><p>Note: On L2, ETH has been replaced by a wrapped ERC20 token — WETH. This is to help the replayability of transactions on L1, which will be explained later. So, the transaction will deposit 10 WETH to the user’s L2 account. Additionally, in reality the bridge contract may be 2 smart contracts working together when a token or WETH is being transferred to L2. These bridge contracts will be provided by the Optimism team at launch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oNQH8Xv3WIoojp7W" /><figcaption>L1 to L2 Transaction Workflow</figcaption></figure><p><strong>L2 -&gt; L1 Transactions</strong></p><p>Transactions from L2 to L1 can be more complicated because in many cases the L1 chain must make sure that the L2 state root after the transaction (which originated on L2) is valid. Generally, the user will send the transaction to a specific smart contract on L2. Then a relayer will read it and send it to L1. Optimism has provided a javascript service that runs as the relayer. It uses the sequencer and verifier nodes to interact with L2.</p><p>To give an example of an L2 to L1 transaction, if a user wants to transfer their 10 WETH on L2 back to ETH on their L1 address, the following steps will happen:</p><ol><li>The user sends 10 WETH to a bridge contract on L2.</li><li>The bridge contract burns the WETH and sends the transaction info to another smart contract known as the L2ToL1MessagePasser. This smart contract records the data for transactions that need to be sent from L2 to L1.</li><li>The relayer node reads this transaction data from the L2ToL1MessagePasser and waits for the fraud proof window (7 days) to complete before sending the transaction to L1.</li><li>The transaction is processed on L1 and the user can now withdraw their ETH. They will withdraw their ETH from the bridge contract that locked it when it was first sent to L2.</li></ol><p>This fraud proof window gives verifier nodes enough time to identify if the state root posted by the sequencer is accurate for this transaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AzEd8NUGBEOcGVUI" /><figcaption>L2 to L1 Transaction Workflow</figcaption></figure><p><strong>Transaction and state root storage on L1</strong></p><p>Since the transaction data and resultant state root for each transaction must be stored on L1, minimizing the size of this data is crucial to lower the storage costs of the system. This is where the term “rollup” comes in. The following steps explain how the data for each L2 transaction is stored on L1:</p><ol><li>The sequencer takes the calldata for a number of sequential L2 transactions and combines them into a single batch.</li><li>Then, the sequencer sends this batch to a smart contract known as the CanonicalTransactionChain.</li><li>The smart contract then hashes the calldata for each transaction and creates a merkle tree of these hashes.</li><li>The CanonicalTransactionChain takes the merkle root of this batch and sends it to a smart contract specifically meant for storage.</li></ol><p>This process is basically rolling up a number of transactions, creating a merkle tree, and storing the root. The same process occurs for storing state roots as well. The contract used to rollup state roots is called the StateCommitmentChain. Now, the only change to the L1 state for a series of L2 transactions is the addition of a new merkle root to the storage contract. This makes the system much more efficient than storing each transaction separately in the storage contract. The following diagram illustrates this process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n0pV5TrgoUtI6wLK" /><figcaption>L2 Calldata Storage on L1</figcaption></figure><h3>Fraud Proofs</h3><p>Fraud proofs are a very important part of the Optimism system and they are what keep the sequencer honest. If the sequencer posts a fraudulent state root to L1, the verifier node can start a fraud proof and execute the corresponding L2 transaction on L1. Then, the resultant state root from the fraud proof can be compared to the state root the sequencer submitted to L1. If they are different, the sequencer’s bond will be slashed and the state roots from that transaction onward will be erased and re-computed. Therefore, it is necessary that all L2 transactions are able to be executed on L1 in a deterministic manner.</p><p><strong>Executing Fraud Proofs — the OVM</strong></p><p>One of the main differences between Geth and L2Geth is that L2Geth executes transactions using the OVM — Optimistic Virtual Machine — instead of the EVM. The OVM is very similar to the EVM but has been modified so that context dependent opcodes (such as TIMESTAMP and ORIGIN) have either been modified or removed. These opcodes would give different outcomes depending on which chain they were executed on. But after the modifications in the OVM, all transactions are replayable on both chains with the same outcome. Essentially, the OVM is a sandboxed environment that allows L2 transactions to be replayable and deterministic on either chain. These features are necessary so that verifiers can create fraud proofs and replay the transactions on L1 to prove what the resulting state root should be.</p><p><strong>Fraud Proof Contracts</strong></p><p>Fraud proofs can be initiated by anyone, but are usually initiated by verifiers since they are checking the validity of every state root submitted by the sequencer. The entire process of fraud proofs are managed by a set of smart contracts on L1 provided by Optimism. Using these contracts, users can replay L2 transactions on L1 to generate the correct state root. The smart contracts will then take care of slashing the sequencer’s bond if the resultant state root doesn’t match the state root posted by the sequencer. In that case, the smart contracts will also handle erasing the corresponding state roots from that transaction onward.</p><h3>Conclusion</h3><p><strong>How does this raise Ethereum’s transaction per second and lower transaction costs?</strong></p><p>Optimism, along with all optimistic rollups, greatly improves the scalability of the Ethereum network and therefore lowers the gas costs (holding throughput constant). In L1 every Ethereum full node in the network will process the transaction, and since the network contains so many nodes, computation becomes very expensive. With Optimism, transactions will only be processed by the small set of nodes — the sequencer and verifiers. So, the computation of each transaction has been moved off of L1 while the transaction calldata remains on L1. This clears a lot of space on L1 and allows many more transactions to be processed. The greater throughput then reduces the gas costs since the competition for getting a transaction added to a block is lower. It remains to be seen exactly how much gas prices and throughput change as Optimism adoption increases.</p><p><strong>Anything special about Optimism’s implementation of Optimistic Rollups?</strong></p><p>One of the great benefits of Optimism’s design is the use of L2Geth and the OVM. Since these systems only make small modifications to Geth and the EVM, they inherit a lot of the well vetted security standards that these components have already demonstrated. This makes security audits of the Optimism design less complicated since there is less brand new software involved. As in most blockchain projects, security is absolutely necessary for the success of the application. Therefore, this feature of Optimism may prove to be invaluable.</p><p>If you’re interested in reading more on Optimism’s optimistic rollup, their documentation goes into much more detail. Additionally, Paradigm has a great article that explains a lot more of the technical details.</p><ul><li><a href="https://community.optimism.io/docs/">Optimism Documentation</a></li><li><a href="https://research.paradigm.xyz/optimism">Paradigm Research: How does Optimism’s Rollup really work?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8450f22629e8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/privacy-scaling-explorations/an-introduction-to-optimisms-optimistic-rollup-8450f22629e8">An Introduction to Optimism’s Optimistic Rollup</a> was originally published in <a href="https://medium.com/privacy-scaling-explorations">Privacy &amp; Scaling Explorations</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>