<?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 The Crypto Realist on Medium]]></title>
        <description><![CDATA[Stories by The Crypto Realist on Medium]]></description>
        <link>https://medium.com/@leor.fishman?source=rss-972066c6ca0a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZkkWTeIIEaSgPCTwkK8AEA.jpeg</url>
            <title>Stories by The Crypto Realist on Medium</title>
            <link>https://medium.com/@leor.fishman?source=rss-972066c6ca0a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 09:54:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@leor.fishman/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[LTO, Part II: Modularity vs. Analogy, or ‘Why not use HyperLedger?’]]></title>
            <link>https://medium.com/harvard-undergraduate-blockchain-group/lto-part-ii-modularity-vs-analogy-or-why-not-use-hyperledger-b98995ac5479?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b98995ac5479</guid>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Tue, 18 Dec 2018 20:27:34 GMT</pubDate>
            <atom:updated>2018-12-18T21:30:24.972Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Part I: Intro:</strong></p><p>For my second piece on LTO, I’ll be comparing their protocol and network to one of the more popular presences in the enterprise blockchain space — Hyperledger. I’ll first be providing brief descriptions of the technologies that LTO and Hyperledger (specifically Fabric) provide, then spending the final part on an analysis of when both technologies are useful and when one would be preferable to another. While I would normally go more in depth on the analysis, my personal life has been relatively hectic these past few weeks, so I felt it better to get out an accurate though short article sooner rather than waiting for a longer one to be feasible.</p><p>Anyway, without further delay, here’s a short summary of what I’ll be covering in somewhat more detail below: LTO’s network is built to allow for construction of near-arbitrary enterprise workflows, rather than specifying specific patterns of behavior — however, it is intended specifically for the domain of workflow reification and processing. In contrast, Hyperledger is intended to provide a tooling ecosystem for a far wider range of enterprise uses (including, e.g., payment processing and larger-scale supply chain formalization and protection) but not to allow much customization within that sphere — if you want to build something allowed by their ecosystem, then use it. If, however, you want to use blockchains to enforce a specialized workflow, then use LTO.</p><p>Conflicts of interest: This article was commissioned by LTO, who may be aiding in some of the LTO-specific use cases. Any contributions from the LTO team will be explicitly marked as such.</p><p><strong>Part II: A general explanation of HyperLedger — Ease by Modularity:</strong></p><p>So, as always, before getting into the differences between the two systems, I will describe each system in general, intending to provide an intuitive picture of the relevant pieces of information rather than perfect formal accuracy. Those who want more information are invited to check the hyperledger website, hyperledger.org.</p><p>Unlike many other projects in the space, Hyperledger cannot be succinctly described as a protocol — instead, it is intended to be a developer ecosystem/tooling ecosystem which is organized around a generalized ethos of ‘building projects for enterprise use’. Therefore, it’s not really possible to give an intuitive explanation of their ‘project’ without looking into the main projects listed on their site — so I’ll proceed to do that. The below are intended only to be short summaries of each project (as you’ll see, reader) to give an idea of their general MO for development. While the relevant comparison here is to Hyperledger’s Fabric project, most of their major projects have the same development ethos.</p><p><em>Sawtooth</em>: One of the first projects in the ecosystem, Sawtooth focuses on building the infrastructure for companies to easily deploy their own distributed ledgers, focusing on making that deployment and implementation a matter of fitting different modular pieces together.</p><p><em>Fabric: </em>This project focuses on building interfaces between lots of separate segments of the blockchain space (e.g. consensus) to make those libraries ‘plug and play’ for the people who want to use them without significant developer windup time.</p><p><em>Iroha: </em>I’m not actually sure what this project is doing differently — it seems to be a blockchain platform intended to deploy in concert with an SQL database?</p><p><em>Burrow: </em>This is a smart contract interpreter (think the EVM) intended to be modular so that any business can spin it up relatively easy.</p><p>I could go on, but I suspect the pattern is already relatively apparent — looking over the previous 4, the approach of Hyperledger is simple: they want businesses to be able to expand into the blockchain/DL space, but those businesses find it too overwhelming/difficult to expand into that space without risking the security and usability of their currently existing platforms. Hyperledger, therefore, is reducing that implementation difficulty through <em>modularity </em>— i.e. rather than having to choose among the massive array of possible implementations for blockchains to build your project, you can instead select from a smaller, known menu of potential options that are all built to work with one another, making it drastically easier to spin up your private or permissioned chain.</p><p>Now, for many cases, this is an excellent approach — however, it does fail in one case. What happens when the tools you need aren’t part of the modular menu? Of course, you can build them into the ecosystem <em>eventually</em>, but mandatory square-one blockchain development was exactly what Hyperledger’s consortium is trying to avoid! This is a general flaw in modular development — you sacrifice the ability to solve arbitrary problems for the ability to better solve some subset of those problems.</p><p><strong>Part III: A general explanation of LTO — Ease by Analogy:</strong></p><p>Now that we’ve explored Hyperledger Fabric’s model in general, we can move on to exploring LTO’s model. Rather than going in depth on their product, I’ll instead copy over the relevant text from my <a href="https://medium.com/harvard-undergraduate-blockchain-group/lto-network-how-reducing-power-increases-utility-bca7ca60bae4">prior article</a> on the project before getting into specifically the relevant parts of their system for this comparison (those who want more information should take a look at the prior article and LTO’s website).</p><p>“ LTO represents [enterprise] workflows as extended Finite State Machines [FSMs], with additional pieces to cover multi-party communications, and uses hamiltonian zero knowledge proofs (as explained in a prior post of mine) to verify to parties that the correct actions within a workflow have been taken without revealing sensitive data.”</p><p>Now, how does this model for development compare with Fabric’s model? It clearly isn’t based on modularity and on combined tooling — but, nonetheless, it seems to be doing <em>something </em>to ease development relative to typical Ethereum development. Take a careful look at that system design — as explained more in my prior article, LTO uses FSMs to represent workflows because, in several ways, FSMs are based on the invariants and properties that are typical of enterprise workflows (the constant number of known states, the constant number of parties involved, having a different workflow for each task, etc). Or, to put it in other words, FSMs are <em>analogous </em>to enterprise workflows.</p><p>Now, why is it useful to establish this kind of analogous system? Well, two reasons. First, because it makes it easier to spot illegal states of the system (illegal used here in the computational sense, not in the legal sense). However, that idea of making illegal states obvious/unrepresentable is something I’ve already covered. For this article, I’m going to focus on a design point — systems that are analogous to their purposes work well because the system model — the way the code works, matches the user model — the way we, as humans, <em>expect </em>the code to work. This sort of analogy and correspondence means that you don’t need to feed the user with lots of instructions about how to get subtle bits of your system working, or warn them about lots of unintuitive pitfalls. Their intuitions take care of that <em>for </em>you. (For more on the subject of user-system model correspondence, including UI focused examples, see <a href="https://www.joelonsoftware.com/category/uibook/">Joel Spolsky’s <em>excellent </em>UI book</a>).</p><p>So, intuitive correspondence and ease of design is the <em>benefit </em>of system design by analogy. What’s the cost? It’s actually quite simple — I imagine many of you can figure it out. When the analogy breaks down, you’re sacrificing power for no benefit. In LTO’s case, once you move outside the space of enterprise workflows that <em>look </em>like FSMs, you lose much of the intuitive design aids granted by the system design. (In other words, you’re now just stuck with a non-turing complete scripting language, with no benefits).</p><p><strong>Part IV: When should you use modularity, and when should you use analogy?</strong></p><p>So, we’ve now established the two development paradigms of this article’s subjects as two potential ways to ease businesses into blockchain development. On the one side, you have Fabric and development by modularity — making development simple by turning it into a plug-and-play like system, where building a chain is a matter of selecting the right options and tuning the right parameters. On the other hand, you have LTO, and development by analogy — making development simple by ensuring the properties of the system exploit that system’s invariants and that the process matches our intuitive models of workflow. So, I imagine you have one burning question: which should I, as an enterprise blockchain developer, be using? I regret to inform you, reader, that there is no simple answer. I can, however, offer a couple of heuristics for which to use when.</p><p><em>Heuristic I: Normal vs. abnormal tasks:</em></p><p>This first heuristic is the simplest — if you’re performing some well-known task like supply chain verification, where all the pieces have been studied and implemented before by others, Hyperledger is likely a better option since some module will likely fit into whatever you need done. In contrast, if you’re building for a specialized workflow (e.g. one-off contract approval, etc) you’re likely to have more success building with a specialized system like LTO’s.</p><p><em>Heuristic II: Speed vs Precision:</em></p><p>This next heuristic is less about the task itself, and more about the constraints on which you have to build. If it’s more important for you to get some sort of system out ASAP, and you care less whether the system matches your problem scenario as long as it gets most of the work done, you’re likely better off finding the closest hyperledger module or set of modules for your scenario. If, on the other hand, you can afford to spend a little bit longer on a purpose-built system, you’re better off building out a precise analogue under LTO’s tooling.</p><p>While I could give more heuristics, they all fall under the same lines — Modularity is good for ‘close enough’ builds that care more about ease of use, Analogy is better for builds where precision and ideal/close enough solutions are worth the slightly larger development run-up time. While, of course, this is an incomplete answer, it gives a good enough set of intuitions to be useful.</p><p>Happy developing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b98995ac5479" width="1" height="1" alt=""><hr><p><a href="https://medium.com/harvard-undergraduate-blockchain-group/lto-part-ii-modularity-vs-analogy-or-why-not-use-hyperledger-b98995ac5479">LTO, Part II: Modularity vs. Analogy, or ‘Why not use HyperLedger?’</a> was originally published in <a href="https://medium.com/harvard-undergraduate-blockchain-group">Harvard Undergraduate Blockchain Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LTO.Network: How Reducing Power Increases Utility]]></title>
            <link>https://medium.com/harvard-undergraduate-blockchain-group/lto-network-how-reducing-power-increases-utility-bca7ca60bae4?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/bca7ca60bae4</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[cryptography]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Mon, 15 Oct 2018 21:32:16 GMT</pubDate>
            <atom:updated>2018-10-17T23:49:12.821Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Segment 1: Intro:</strong></p><p>For my third article, I’ll be taking a request from the company LTO.Network (referred to hereafter as LTO, for short) to analyze and explain their systems, particularly as they compare to other blockchains in potentially relevant spaces. Specifically, LTO is designing enterprise-focused individual blockchains that are each meant to represent a specific process flow between multiple divisions or companies. These enterprise and task-specific blockchains enable a granular, easily modifiable representation of workflows that turns every workflow into an enforceable, validatable contract. In short, think of LTO’s work as smart contractifying enterprise workflows. Well, not quite — in fact, the difference between smart contracts/LCs and LTO’s computation, called Live Contracts/LCs, will be the primary focus of this paper. But I’m getting ahead of myself.</p><p>Before briefly technically describing the system, I should take a bit of time to discuss my biases here. This is an article I was approached by LTO and asked to write, and I’ve had a number of conversations with their technical team and CTO about the white paper — so on an intuitive level, I’ll probably be predisposed to the system the same way I was towards Solana and Enigma. However, as with those two, I will be pointing out all concerns I have with the system as they become relevant.</p><p>Now that I have explained my bona fides, we can move on to LTO’s tech, their Live Contracts. For the more technically minded, LTO represents workflows as extended Finite State Machines, with additional pieces to cover multi-party communications, and uses hamiltonian zero knowledge proofs (as explained in a <a href="https://medium.com/harvard-undergraduate-blockchain-group/privacy-and-secrecy-a-general-analysis-f39dcd6a709f">prior post</a> of mine) to verify to parties that the correct actions within a workflow have been taken without revealing sensitive data.</p><p>For the less technical, here’s a short summary of the above: LTO uses a strictly <em>less </em>expressive system than smart contracts to represent business workflows. Specifically, their chosen system is incapable of representing arbitrary computations, and is more like Bitcoin’s scripting language than ethereum’s in terms of power, albeit with a little more power than Script. Also, LTO’s systems include inbuilt zero knowledge proof capability, as explained in my prior piece on privacy and security. In this enterprise case, zero knowledge is exactly what workflows need — since each enterprise knows the work/portion of the task they’re doing regardless, and the only necessary privacy is that other enterprises not discover that information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r6CVGx8EIwENACm7c4ku_w.jpeg" /><figcaption>A sample LTO Live Contract</figcaption></figure><p>So, there’s a description of the Live Contract system. Now, we can dive into the main body of this article: given that smart contracts exist, and, as said above, they are more expressive and powerful, why use Live Contracts at all?</p><p><strong>Segment 2: Generalized thesis: More options not always better</strong></p><p>Now, I expect that the idea of ‘losing options can be beneficial’ will seem almost paradoxical to many of you. As well it should! At first glance, the idea that having more choices and more expressive power can lead us to <em>worse </em>alternatives is seemingly patently ridiculous. It is therefore time to explain why your intuitions are (sometimes) <em>dead </em>wrong. We’ll begin, first, with an example from outside the CS world of option restriction.</p><p>I imagine many of you are familiar with the game of Chicken — for those of you who aren’t, however, I’ll provide a brief explanation. Basically, the game proceeds as follows: 2 people drive towards each other, and the first one to brake or swerve loses. If, however, the cars collide, then both people lose — and, of course, now have to fix up their cars!</p><p>Now, consider playing a game of chicken normally. Whether to swerve or not at each instance is a complicated decision, based on what you know of the other driver, how much you value winning, and so on. Let’s make life a little easier on ourselves. What if, before the game started, you called out to the other driver and just…destroyed your steering wheel? Now, you know the other driver <em>has </em>to swerve — if you drive forward, either he loses or he loses <em>and </em>has to fix his car. Clearly, despite the fact that your only action was <em>restricting your options</em>, you’ve made your position in the game far better! (this is, of course, slightly oversimplifying — in particular it elides the case of what happens when you, midway through destroying your steering wheel, look up to see your counterpart smashing his. Which is, of course, far from ideal. But I digress.)</p><p>Now, that’s one example. I can already hear your responses, though — so what if it makes sense in a contrived game like chicken? What does that have to do with real-life situations and the expressive power of code? Quite fair. I’ll now move to a more relevant example — but it will mean going into a bit of computer science. First off, consider a normal computer — you can read in large amounts of data, the system can hold one of many possible states, and you can push and pull lots of data from working memory. This intuition about computers can be formalized as an entity called a <a href="https://www.wikiwand.com/en/Turing_machine">turing machine</a>/TM — think about TMs as an extremely simple computer with its own internal state that operates on an extremely long line of tape, where the tape serves as input, memory and output. At each step, the computer reads in the tape at its current spot, then based on its internal programming and current state makes 3 choices: 1) how to update its current state, 2) whether to change what’s on the tape below it, and 3) whether to move right one space, left one space, or stay still. Now, this seems incredibly simple, but in fact is provably equivalent to modern computing in terms of power — anything our machines can compute, so can a turing machine (albeit given a <em>lot </em>more time).</p><p>Now, TMs are well and good — but, sadly, there’s one big problem with them. It’s very difficult (and, in fact, <a href="https://www.wikiwand.com/en/Rice%27s_theorem">provably impossible</a>), to analyze certain facts about TM programs (and thus modern computer programs). In particular, analyzing nontrivial semantic properties about a program — i.e. figuring out a program’s behavior on general classes of input — is provably not possible. To give a simpler example, say you have to solve some task, like going through a long list and picking out the odd numbers. You don’t want to code a script to do it, so you send it out to your friend. Your friend sends you something completely unreadable, but it does <em>seem </em>to be a well-formed program — so if you could analyze it to make sure it actually took out all the odd numbers, that would be good enough. Unfortunately, you provably can’t for a general task of this sort — while you can check the program’s performance on test cases, that doesn’t show you that the program works perfectly unless your test cases are perfect! This is obviously an untenable situation for tasks where we need to be sure our code will work every time — the rise of code auditing businesses shows us that much. However, is this how development <em>has </em>to look?</p><p><strong>Segment 3: Make illegal states unrepresentable:</strong></p><p>At the end of the last section, I left you all with a seeming catch-22: developing on Turing machine equivalent devices — which all computers provably <em>are — </em>leaves us with the paradox of untestability — we can’t build test architectures to ensure a program works perfectly unless our test architecture is also itself perfect! Now, we have two paths we can take from here. 1) accept this vulnerability as a necessity, and focus on building good enough tests to get around it. This path is the only feasible one for <em>generalized </em>development, and is what we therefore need to content ourselves with most of the time. It isn’t perfect, though — and many recent bugs in the cryptocurrency market can be traced to failures of test architecture in checking for common mistakes (take, e.g., reentrancy bugs, a common failure state of many SCs including but not limited to the original DAO). However, if we know something about our problem/task’s structure, we can take advantage of that for path 2) formalize certain <em>invariants </em>(things which are always true) in order to make certain classes of failure states not only difficult, but <em>impossible </em>to represent.</p><p>Let me explain the above with a simple example. Imagine we’re building a system meant to handle the buying and selling of widgets that come in packs of four. Now, we could just represent the amount of widgets as a raw number, and rely on all the functions handling buying and selling to only be fed numbers that are multiples of 4 by the customers/employees. But that’s a great way to immediately run into a catastrophic bug when somebody screws up, and we inexplicably have an extra widget in the system that nobody can account for. We could, of course, also fill our software with test cases to ensure we’re only using multiples of 4 — and, for something this simple, that wouldn’t even be that hard. But there’s a simpler way. What if, instead of focusing on the number of widgets, we instead represented by the number of <em>packs </em>— and only multiplied by 4 in the last step before displaying ‘widget number’ or before calculating price per widget? Then we wouldn’t even have to test that invariant: it would be <em>impossible </em>to store a number of widgets in the system that wasn’t a multiple of 4!</p><p>That widget example is simple, but nonetheless explains the idea behind invariants: you can profitably restrict your ability to represent information in order to make errors not only avoidable, but <em>unrepresentable. </em>Therefore, even though you might still be developing on an unverifiable machine, you can restrict your ability to use that machine to a subset of <em>verifiable </em>uses. This is the insight behind Live Contracts, which we’ll cover in more detail in the next section.</p><p><strong>Segment 4: LCs vs SCs:</strong></p><p>Now that we’ve described the concepts behind invariants, and how restricting computational power can lead to more useful and less error prone systems, we can move on to comparing LCs to the more typical SC. Before getting into LCs, let’s first explore the smart contract side — this turns out to be rather simple: Smart contracts, as a general class, are Turing-equivalent. They can do all the computation a normal computer can do, but are just as limited by lack of non-test verification.</p><p>Now, onto Live Contracts. Before describing the system, let’s first get an idea for what invariants we want to be working under. Remember: the problem domain is Enterprise Workflow, with each LC existing to solve a particular task. What is the maximum amount of power we need, and what assumptions/invariants can we rely on enough to reify?</p><p><em>Invariant 1: Constant Numeracy Of Parties: </em>We can first note that any individual enterprise task is going to pass through the same number of divisions and companies as it did every other time it was performed (though different amounts of effort might be required at each stage). This means that we can keep all contracts <em>bounded </em>in size — i.e., we can make an LC for a specific task expect inputs from a certain number of people, in a specific order (or one of a set number of possible pathways).</p><p><em>Invariant 2: Sequential Steps: </em>Enterprise workflows are generally a matter of tasks taken in a specific order and completed one after the other — first you requisition something from one company or send something to them for signature, and <em>then </em>it gets returned/accepted/denied and you respond, and so on. We can generally assume that either events within a workflow are sequential, or that events which happen in parallel can be packaged into single events within the chain of sequential events.</p><p><em>Invariant 3: Constant number of known possible states: </em>When we create a workflow, we know that the system the workflow is modeling can only be in a certain number of possible states, represented by the nodes within that workflow. If, for example, our workflow for a given contract specifies that a company can either be in contract, waiting for contract reception, or out of contract, we don’t need to worry about the case that the company is both out of contract and waiting for reception (the question of what to do with a state like that in real life is an important one! But it’s a question of workflow design accurately representing reality, not of representing those workflows programmatically).</p><p>Those are the main invariants we can rely on — note crucially that neither <em>determinism </em>(the lack of randomness) or <em>Information-completeness </em>(not needing outside-workflow information to determine the correct next state) are assumed here. The first allows us to account for things like communications failures within the workflow, the second allows us to model things like ‘we’ll build this system contingent on our outside contractors approving it’ without extending a workflow to include the entire approval process.</p><p>So, now that we have these invariants, is there a system which handles them? Turns out, the answer is yes: the aforementioned Finite State Machine based model on which LCs are based. FSMs are just powerful enough to allow for computations with the requirements we’ve described, but weak and unexpressive enough to allow for analysis and formal verification.</p><p>So, what can this system actually get us? Let’s explore a couple of simple examples of enterprise workflow that LTO makes easy.</p><p><em>1: Multi-party Contract Signing:</em></p><p>Imagine that you have some contract that you want to transfer among some preset number of parties, with signatures coming from each party, and with the contract potentially changing from signature to signature with any change requiring resigning from all parties. In the current world, the only way to do this sort of thing would be with human conveyance of the contracts, or trying to graft together multiple internal electronic systems. Under LTO, this is an incredibly easy system to model and verify (store a hash of the contract as on-chain data, have states of every combination of parties signing, reset to initial state when the hashes don’t match). This system as presented does require a new contract for each potential combination of parties, but this is analogous to needing a new contract when a new party gets involved in a deal in the real world.</p><p><em>2: Encrypted Data Transfer:</em></p><p>Imagine that you have some piece of encrypted data that you want to pass from party to party under preset rules, in such a way that you can verify the limitations on that data access <em>statically — </em>i.e. Without exposing the data to any risk of loss. In the current world, we’d be limited to automatic testing/pentesting of the smart contracts/access control solutions under which the data was stored and transferred. Under LTO, it’s possible to formally analyze and verify the live contract controlling access to the data, increasing security and decreasing the risk of data security being compromised. I.e. we don’t need test cases to verify the functionality of our data transfer, and can analyze the contract without needing sample cases/uses.</p><p>Of course, LTO has more use cases than just these — the two chosen are ones that LCs are particularly powerful for.</p><p>Now that we’ve explored the motivations for LCs, have we said all there is to say? No — there are a few more pieces of the LC system to explore, as well as a couple of points to make about when <em>not </em>to use LCs — the lack of power does cost you certain use cases for which a standard smart contract or traditional database might be better suited.</p><p><strong>Segment 5: Desideratum and Conclusions:</strong></p><p>Now that we’ve covered the bulk of LTO’s Live Contracts system, all that’s left is to cover a few more side points before ending with a succinct conclusion.</p><p><em>Side Point 1: The Oracle Advantage:</em></p><p>As any of you who have been following projects like Chainlink may know, current smart contract systems have a lot of trouble integrating oracles, or third party information sources, into the running of the blockchain. Now, this happens for a number of reasons, but the primary one is that there’s no clear way to integrate oracles into existing blockchain systems in ways that preserve the security of the system/formalize the roles of those information sources. (This isn’t to say that such a development is impossible, far from it — merely that it’s, as of now, a problem <em>without a standardized solution</em>). Under LTO, meanwhile, oracles can be modelled as another party to any given workflow as long as their responses can be succinctly characterized (i.e. only discrete oracles can easily be modeled under an FSM). While this doesn’t allow for total oracle integration — in particular, oracles providing analog information don’t neatly weave into LTO’s systems, it does provide a solution for many common use cases.</p><p><em>Side Point 2: What </em>doesn’t <em>LTO do:</em></p><p>Much of the above article focused on the fact that LTO was intentionally limiting their own expressive power, but I didn’t actually provide any examples of concrete tasks that FSMs cannot perform. So, here are a couple of simple examples that should hopefully provide a good intuitive picture of where FSMs fail.</p><p><strong>1: Unbounded Voting:</strong></p><p>Imagine you want to take votes from some arbitrary number of people for or against a policy, then return the winner. Doing this with smart contracts is easy — in fact, a more complex version of this is, quite literally, the demo contract on Redux. However, doing this with an FSM and thus an LC is provably impossible (I won’t go into the proof here due to lack of space, but the short version of it is that FSMs are provably equal to regular expressions, and there’s a simple reduction from unbounded voting to Parenthesis Matching, a problem which regexes provably cannot solve).</p><p><strong>2: Analog End States:</strong></p><p>Imagine that you have some workflow where you want to take in the risk assessments of a number of parties and return a normalized average or product of those assessments. With a typical SC on a private blockchain, this is simple — just have each party submit their assessments and compute the desired function. However, on LCs, we’re limited to digital/discretized end states, and therefore can’t return an end state which is an analog normalization of data.</p><p>Now, it should be emphasized that these failings aren’t unsolvable — in particular, both could be solved by allowing subsections of an FSM to be represented by an internal SC, in effect sacrificing a portion of contract verifiability for added functionality. And this, in fact, leads me to my conclusion.</p><p><strong><em>Blind Comparison Of Relative Capabilities is Almost Meaningless.</em></strong></p><p>Let me explain what that means. Say you took a latex glove and a winter glove and compared them among several axes: protectiveness, ability to withstand elements, and durability. The winter glove wins along all 3 axes — and, nonetheless, nobody would prefer their surgeons wear winter gloves while operating. So why are we doing blind comparison between cryptographic projects? It seems, to me, like the better course of action is seeking to explore how well each project is optimized around the demands of its market and problem — <em>that </em>is asking the relevant question.</p><p>Postscript: at LTO’s request, I’ve attached links to their public presences below:</p><p>Website: <a href="https://lto.network/">https://LTO.network</a><br>Technical paper: <a href="https://bit.ly/2IUJhdp">https://bit.ly/2IUJhdp</a><br>Twitter: <a href="https://twitter.com/LTOnetwork">https://twitter.com/LTOnetwork</a><br>Medium: <a href="https://medium.com/LTOnetwork">https://medium.com/LTOnetwork</a><br>Telegram: <a href="https://t.me/LTOinfo">https://t.me/LTOinfo</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bca7ca60bae4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/harvard-undergraduate-blockchain-group/lto-network-how-reducing-power-increases-utility-bca7ca60bae4">LTO.Network: How Reducing Power Increases Utility</a> was originally published in <a href="https://medium.com/harvard-undergraduate-blockchain-group">Harvard Undergraduate Blockchain Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dark DAOs and the Complexity of Secret Voting]]></title>
            <link>https://medium.com/enigmampc/dark-daos-and-the-complexity-of-secret-voting-fc3b4fe4d666?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc3b4fe4d666</guid>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[bitcoin]]></category>
            <category><![CDATA[voting]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Thu, 09 Aug 2018 15:07:27 GMT</pubDate>
            <atom:updated>2018-08-14T10:09:13.923Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This is Part Six of the </em><strong><em>Enigma Solutions Series</em></strong><em>, examining real-world decentralized solutions that can be built with Enigma’s groundbreaking protocol.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iSPYbh_hqSQw9JgZUyBNJg.png" /></figure><p>Over the past few months, Enigma has published a number of blog posts called the <a href="http://blog.enigma.co/solutions">Solutions Series</a>, focusing on the various real-world applications that can be built using their groundbreaking privacy protocol. One particular post focused on <a href="https://blog.enigma.co/private-voting-for-tcrs-with-enigma-b441b5d4fa7b"><em>secret voting</em></a><em>, </em>and how the Enigma protocol allowed for truly private elections <em>simply, </em>without the complexities and security holes induced by commit-reveal voting schemes.</p><p>A few weeks ago, a <a href="http://hackingdistributed.com/2018/07/02/on-chain-vote-buying/">blog post</a> detailing a potential flaw in such secret voting schemes — and, for that matter, in <em>any </em>decentralized voting scheme — was described online. Today, rather than focusing on another of Enigma’s potential solutions, we shall be analyzing this specific flaw and how one might be able to protect against it. <strong>Welcome to the world of the Dark DAO.</strong></p><h3><strong>What is the attack?</strong></h3><p>Before describing the attack itself, we should note the <em>environment </em>in which the attack takes place, as well as its goals.</p><h4><strong>Attack environment:</strong></h4><p>The attack assumes the existence of four factors:</p><p>1) Code that can run on encrypted data in a malicious environment <em>without </em>revealing that data to its host. This is possible (to varying extents) through both Secure Multiparty Computation (sMPC) or Trusted Execution Environments (TEE) technologies.</p><p>2) The ability to <em>commit </em>to running a specific piece of code, and to attest that a certain piece of code is all that is running on a given machine. This requires TEE technology.</p><p>3) The ability to send in a vote given only a specific piece of information e.g. a voting key/private key, without any nonymizing information attached to the vote. This is standard in decentralized voting schemas.</p><p>4) One voting outcome is worth significantly less to any one voter than their stake is — i.e. the total effect of any given vote is less than the total value of the tokens. This is not policy anywhere, but should be expected — how many tokens are deciding their entire fates with every governance question?</p><h4><strong>Attack goals:</strong></h4><p>This attack aims to provide a way for some arbitrary bribing organization to control the votes of external parties for a <em>single </em>poll, no more and no less. Note that qualifier — it’s not enough for the briber to just <em>buy </em>the voting keys off of his intended targets, since in that case he can do anything he likes with their tokens (assuming the voting keys and private keys for tokens are linked, which is standard in most schemes) — and thus bribing is only as useful as token purchasing. For the attack to be <em>dangerous</em>, it must be significantly less risky (in terms of the future value of the voting tokens) for someone to sell a single vote to the briber than it would be to give up their tokens — then the incentives misalign themselves in the briber’s favor.</p><h4><strong>The attack itself:</strong></h4><p>Now that we’ve described the environment and goals, the attack itself follows relatively simply.</p><p>The briber sets up code to run on an SGX machine that does the following: When sent an encrypted private key for a given voter, it decrypts the key within the enclave, then uses that key to vote. If no other votes with that same private key are sent in until the election concludes, then the SGX machine sends some pre-known bribe to the voter in return (this delay is necessary because the user still holds their key, and could thus override the SGX vote). Now, before SGX/TEE technology, such an attack wasn’t really feasible — after all, if the briber knew the voting key, they could just use that key to move the tokens as they saw fit. However, with the new capabilities enabled by private computation, the briber can provably use the keys they collect for votes, and <em>only </em>votes.</p><p>In fact, SGX enables more than just single briberies — since the briber can do such a thing <em>programmatically</em>, they can use a slightly different bribery program. Rather than soliciting a specific user, it merely waits and collects <em>any </em>voting keys sent to it. If there aren’t enough keys sitting in its internals to win the vote, it does nothing. However, if it would win — <em>then </em>it springs into action, launching its votes and repaying its bribees. This system allows for fully autonomous election control, without <em>any </em>risk to the bribees and without the briber needing to target anyone explicitly — all they have to do is set up the contracts and watch them run. <em>This </em>is the power of Dark DAOs.</p><h3><strong>What is the defense?</strong></h3><p>Now that we’ve described the attack, we can proceed to analyze potential defenses against it. Note that the requirements for the attack to function were: code operating on encrypted data privately, the ability to attest to a specific piece of code’s being all that was run, no nonymizing information attached to a vote, and each vote being worth less than the voter’s overall stake. We shall cover these conditions, and the imperfect defenses they lead to, in reverse order.</p><ol><li><em>The worth of votes: </em>Obviously, if someone’s vote could potentially devalue their entire stake, no briber will be able to purchase votes from people for less than the price of their stake (assuming the risk of devaluement is high). However, exploiting this to secure votes against a dark DAO requires ensuring that <em>any </em>vote could make or break a currency — a risky, undesirable proposition.</li><li><em>Nonymizing information: </em>if votes are tied to personal identity, bribers will not be able to automatically purchase them — however, this ruins the decentralized, anonymous nature of the voting schema.</li><li><em>Attestation that the code run reveals nothing about the data:</em> At first glance, it might seem impossible to break this certainty given the security of SGX. However, there is a way to falsify this assumption — at the cost of decentralization in our hardware. Namely, consider the case where we require <em>all </em>voters to use SGX machines to store their keys. Additionally, require the SGX machines from which the vote is placed to <em>verifiably </em>pass their voting keys to their hosts. If the voter is using their own machine, this isn’t an issue — they already have the key. However, this prevents bribers from being able to verify that their use of voter keys is only for voting — since the vote itself will expose the voting key to the briber’s host. This solution solves the dark DAO problem — but requires all voters to have SGX hardware to vote.</li><li><em>The ability to run code on encrypted data without revealing it:</em> we can break this assumption under similar constraints to 3, by requiring the code run on the data as part of voting <em>to </em>reveal it. This, again, requires all keys to be generated under SGX hardware.</li></ol><p>It’s clear that voting has become a promising and valuable primitive for the decentralized ecosystem, whether it comes into play for governance decisions at a protocol level, or granular TCR-style decision making. It’s also clear that voting can be a high-value target for attack. Trusted hardware like Intel SGX enable new vectors for vote manipulation. This is an emerging space, and we expect to see more new and creative applications of these tools.</p><p>Based on this analysis, we can ask a few questions of the community:</p><ul><li>Is generating keys under SGX hardware a feasible response?</li><li>How can this be made more accessible — perhaps through a plurality of TEE solutions or creating compatibility with TEEs in mobile devices?</li><li>Are there potential transaction-level proofs to these attacks?</li></ul><p>As Phil Daian notes in the piece that inspired this response, “coordination space of mechanisms in blockchains is large, and the environment hostile.” However, the importance of data privacy and private voting is very clear to us, and we’re excited to continue pushing research and tooling in this area.</p><p><em>Come discuss these open questions on the </em><a href="https://forum.enigma.co/t/dark-dao-sgx-voting/251"><em>Enigma Developer Forum</em></a><em>!</em></p><p><em>This Solutions article is a contribution from a member of the Enigma team. Thanks to Luke from Aragon, whose insight was very helpful in writing this piece.</em></p><p>Do you want to help Enigma find solutions for the challenges facing our decentralized future? <em>You should join us.</em></p><p><strong>Learn more about our project</strong> on our <a href="http://enigma.co/">website</a> and <a href="http://blog.enigma.co/">blog</a>.</p><p><strong>Join our developer community: </strong><a href="http://forum.enigma.co/"><em>forum.enigma.co</em></a></p><p><strong>Want to build on our protocol?</strong> <a href="http://enigma.co/protocol">Check out our documentation</a> to get started — or, if you’re a project or enterprise, <a href="https://airtable.com/shraD9Oo5HPmRR9eE">submit your interest here.</a></p><p><a href="https://airtable.com/shrptg7c6Oo9ZxKEO"><strong>Join the Enigma Team</strong></a><strong>:</strong> <a href="https://enigma.co/team/"><em>enigma.co/team</em></a></p><p><strong>Telegram:</strong><em> </em><a href="http://t.me/enigmaproject"><em>t.me/EnigmaProject</em></a></p><p><strong>Reddit:</strong><em> </em><a href="http://reddit.com/r/enigmaproject"><em>reddit.com/r/EnigmaProject</em></a></p><p><strong>Twitter:</strong> <a href="http://twitter.com/enigmampc"><em>twitter.com/enigmampc</em></a></p><p><strong>Discord</strong>: <a href="https://discordapp.com/invite/SJK32GY"><em>https://discordapp.com/invite/SJK32GY</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc3b4fe4d666" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enigmampc/dark-daos-and-the-complexity-of-secret-voting-fc3b4fe4d666">Dark DAOs and the Complexity of Secret Voting</a> was originally published in <a href="https://medium.com/enigmampc">Enigma</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Privacy and secrecy: a general analysis]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/harvard-undergraduate-blockchain-group/privacy-and-secrecy-a-general-analysis-f39dcd6a709f?source=rss-972066c6ca0a------2"><img src="https://cdn-images-1.medium.com/max/600/0*o_FhOtRSAuIyA_ij" width="600"></a></p><p class="medium-feed-snippet">Now, for my second major post, I decided to take on something different &#x2014; rather than an overview of a specific project, I&#x2019;ll be writing&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/harvard-undergraduate-blockchain-group/privacy-and-secrecy-a-general-analysis-f39dcd6a709f?source=rss-972066c6ca0a------2">Continue reading on Harvard Undergraduate Blockchain Group »</a></p></div>]]></description>
            <link>https://medium.com/harvard-undergraduate-blockchain-group/privacy-and-secrecy-a-general-analysis-f39dcd6a709f?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/f39dcd6a709f</guid>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Fri, 20 Jul 2018 15:00:00 GMT</pubDate>
            <atom:updated>2018-09-12T19:50:01.753Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Solana: Achieving speed through measurement of time]]></title>
            <link>https://medium.com/@leor.fishman/solana-achieving-speed-through-measurement-of-time-1d2a6b434649?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d2a6b434649</guid>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Thu, 14 Jun 2018 01:04:36 GMT</pubDate>
            <atom:updated>2018-06-14T01:04:36.190Z</atom:updated>
            <content:encoded><![CDATA[<p>For my first in-depth review, I thought I’d take a look at a project that I’ve been hearing quite a lot about: Solana. There’s been a good deal of buzz about what they’re building, so I figured I’d cut through the hype and <em>describe </em>what the Solana blockchain is, piece by piece. In short: Solana aims to solve the scalability problem of blockchain transactions by replacing the Proof of Work model of verification and resource commitment with a Proof of History/Proof of Time model, augmented by Proof of Stake for electing the generators of that Proof of History record, using Proofs of Replication to store the system’s state. We’ll now go into <em>explaining </em>each one of those terms, then circle back to a complete picture of the system.</p><p><strong>Section 1: The Problem of Scalability, and the impact of Proof of Work models:</strong></p><p>Blockchain has a scalability problem. I suspect nobody reading this will be surprised by that — the largest cryptocurrencies can take minutes to process transactions even with relatively high values for the transactions. This scalability problem is based, in part, on the way blockchains preserve validity: by associating a serious computational <em>cost </em>with creating a new transaction, thus incentivizing people to add valid transactions onto a chain rather than trying to create and have validated invalid txs, to flood the market with fake transactions, or to create an invalid chain.</p><p>This is all well and good in theory, but in practice this leads to steadily <em>growing</em> transaction costs — let’s look at a simplified version of why. The current computational cost model of proof of work models is based on a series of <em>parallel </em>queries to a hash function (for the less technical: think about it like asking for a random number, where you win if the number is low enough) . Obviously, this sort of thing becomes easier as computers become more and more parallelizable (for the less technical: think about this like asking for more and more random numbers per second, you’ll obviously find the right one more quickly). Now, if you want to make sure someone with a few more cores doesn’t overrun the entire market with fake transactions, you have to make the range of random numbers bigger — so it takes even the groups with the largest amount of computing power long enough to find valid transaction headers to make fake branch generation infeasible. Now, that preserves security, but does so at the cost of speed — transactions rapidly grow to being too costly to be usable, since parallelism is relatively cheap.</p><p>Now, there are a number of ways to get around this problem — mostly revolving around converting the cost of transactions into something noncomputational: e.g. proof of stake systems, where someone stakes some valued share in the system to validate a transaction. These systems escape the failure mode of spiraling computational costs, but introduce a new risk of centralization — the more tokens you have, the more easily you can risk faking transactions. Additionally, those methods themselves can sometimes be slow.</p><p>Looking at this whole system, one can’t help but wonder: is there some way to impose a computational cost that <em>isn’t </em>vulnerable to parallelism? Some way to ask for random numbers that doesn’t become easier with more cores? Such a method would allow for ensuring a transaction’s validity with cost, but would make it substantially less likely that that cost would need to be <em>shifted </em>— increasing the speed of a CPU substantially is far harder than just adding more cores. However, such a system would have to look substantially different than proof of work — in particular, it wouldn’t be enough to just require plain hashes — since those can be parallelized.</p><p><strong>Section 2: Proofs of History, and the sequential work/chain model:</strong></p><p>So, we now have our problem — we want a meaningful way to impose computational cost, in order to ensure that real time is sunken into creating transactions to prevent transactional spam as well as to construct a coherent order of events to stop double-spending and to ease network verification. How might a solution to this problem work?</p><p>Let’s first imagine an ideal, simplified world to get a sense of what a solution <em>might </em>look like. Imagine, for a moment, a world in which the only computing available was the add 1 operation — you have some machine which, given a number, adds 1 to it and returns the output (of course, for this thought experiment, you have to assume that humans are incapable of adding — if it makes it easier, assume the only operation is something like tetration which is human-hard.). These machines can, however, be run in parallel. Now, there’s an obvious way to solve our problem: if you want to confirm that some computation took X timesteps to evaluate, require someone to attach 2 numbers to the transaction: the number they started with, and the output of adding 1 to the number X times. Now, I can already hear you arguing “wait, but doesn’t that mean people could reuse their number pair over and over again”? Quite right, reader. You would also have to impose some rules on what the starting number could be — as a first approximation, say it has to be the number the <em>previous</em> person outputted for their process. Additionally, though under our approximation it isn’t necessary, consider how you would encode the state of the system into the number as well — perhaps by using a pair of numbers combined into 1 before adding?</p><p>This, now, is our intuitive, simplistic version of what’s known in cryptography as a Verifiable Delay Function, or VDF — a function that sounds like exactly what it is — something that cannot be parallelized, and that gives information about time passing based on the number of recorded invocations. Before we jump into what Solana’s VDF is, there is one more thing we need to cover: ease of verification. Under our system as constructed, the people <em>verifying </em>that time passed take just as much time as the prover did to construct his proof — X timesteps in both cases. Now, obviously, that’s not workable for a production-ready system. Instead, we’ll have the prover post a few <em>intermediate </em>numbers along the way, in effect putting landmarks on his computational path, slicing it up into many individual pieces. Then, people trying to verify his time can evaluate those slices in <em>parallel</em>, reducing their effort by a multiplicative factor (e.g. if there are 2 slices, verification takes one half as long as proof, etc.).</p><p>Now, we have to note one more issue with our system as constructed — it’s all well and good against honest participants, but what happens if we have adversaries attempting to produce false orderings, eliminating or reversing events? The operations we have are no longer enough to deal with that scenario — we need, instead, a function which verifiably encodes <em>event </em>information as well as timestep information, in a way which cannot twisted into encoding an event which wasn’t inputted into it — in other words, we need a function which is collision-resistant. A function like that would allow us to prevent reversal of events, and would allow us to encode the data about which events occurred when into the <em>timestep </em>itself, rather than just attaching data to the timestep. In other words — in order to solve adversariality, we need hashing.</p><p>So, that’s our simplified version of the system: Solana’s actual Proof of History system should, hopefully, make sense to you all now — even with a few more complexities. Firstly, Solana’s VDF, instead of being simple addition, is a collision resistant/cryptographically secure hash function(these two aren’t quite the same, but for this level of abstraction we can consider them as such) — and the pair of input output is instead an input of the prior system state (timestep count, transaction, previous hash) with the output as the new timestep, new data and new hash, including intermediate hashes to slice up the chain for verifiers. Because the hash function has been repeatedly optimized over the past few years to near maximal efficiency (because of Proof of Work chains), it can be assumed that the maximum known speed of the hash operation is <em>reasonably </em>close to that of the maximum possible speed, and therefore the number of hashes in a chain is a pretty fair approximation of the time spent to construct that chain. Additionally, as explained above, hashes allow for the encoding of additional information about external events and signatures within hash chains — if, for instance, you want to ensure the order of events is preserved, you can combine each event with a prior hash when creating the next timestep — a verifier can easily see whether the events are in the order they need to be to create the observed hashes. Similarly, you can interleave the sequences of various generators by using links in one’s hash chain as data for the other’s future hashes and vice versa, enabling the mixing of high bandwidth proof of history generators (which intermix lots of order-preserving events) with lower bandwidth, faster generators to lower the computational and communications load on the system.</p><p><strong>Section 3: The Avalanche proof of stake: Are PoHs enough?</strong></p><p>We’ve now constructed the basis for the Solana PoH system: a way to encode information about system state as well as system order in a way that is easily verifiable. Now, we need a way for that encoding to be distributed and validated in a decentralized system, ideally in a way that provides for a mix of consistency (the system always returning an up to date response about its state, even if that state is an error) and availability (the system always returning some response, even if it’s not as up to date as it can be) when certain nodes are nonresponsive — it’s impossible to get both of these perfectly under a partition scenario, as shown by Brewer. We also need this consensus protocol to be <em>quick </em>— if we lose lots of time to connecting to every verifier node in a system, there’s no point in having a quick proof of computational effort like PoH — we’ll lose all that speed on the backend.</p><p>Intuitively, what we want is a system with the following properties:</p><ol><li>if someone generates a Proof of History sequence, we want it quickly passed to the verifiers in a way that doesn’t become quickly more expensive as the network grows — <em>efficient growth</em>.</li><li>We also want these verifiers to be incentivized to verify it or falsify it, and to only verify one sequence if they receive two conflicting alternatives — <em>accurate verification</em>.</li><li>If there are insufficient verifiers to vote yes or no, or too many of them are inactive, we want the system to recognize that and dynamically update the number of verifiers who <em>need </em>to vote — <em>dynamic thresholds</em>.</li><li>If the generator is found to be incorrect, we want there to be some sort of penalty for both the generator and those who verified that their sequence was a correct addition to the preexisting chain — <em>error responses</em>.</li><li>Finally, we want a clean way to designate new generators if preexisting generators are found to be failing either intentionally or unintentionally — <em>clean transitions</em>.</li></ol><p>Let’s look now at how Solana’s system plans to achieve each of those properties.</p><p>Solana’s Avalanche proof of stake system works as follows: at each time-step, you have one person responsible for receiving new transactions and collating them into a complete proof of history sequence — call this person the generator. The generator then passes off their suggested state to verifiers in a tree structure — the generator passes pieces of their state to some constant number of verifiers, each of whom passes the pieces they received both to the verifiers on their level and to a number of lower level verifiers. In this way, there are only a relatively small, constant number of connections happening for each level of the tree — so the amount of network connections increases <em>logarithmically </em>with the network size. In other words, the <em>additive </em>time difference between 10 and 50 nodes is the same as the difference between 10,000 and 50,000, providing us with <em>efficient growth</em>.</p><p>All generators and verifiers in the system lock up a certain amount of their tokens in untouchable bonds, which are taken from them if they are found (in the case of the generator) to have generated an incorrect sequence or (in the case of the verifier) to have voted for an inaccurate sequence or to have voted for two sequences at once. Additionally, if the generator generates incorrectly, they are removed from the position of sequence generation. On the other hand, if they verify correct sequences or generate correct sequences, they are rewarded with more tokens (the precise amount is currently unclear and has been described by a developer as ‘one of the knobs that can be twisted’). This provides us our <em>accurate verification</em> and our <em>error responses</em>.</p><p>Now, if there are enough verifiers not voting/ a split vote, Solana’s system in the short term will pause the consensus — their algorithm uses a 2/3rds consensus/supermajority voting condition (as do many). However, the system will recover from such a partition event — if a node is found to have not voted for a long enough period of time (which, because of the construction of PoH, we can verify across the network) that node will have its bond returned, and its right to verification revoked. This will cause the threshold for 2/3rds supermajority to decrease, and eventually cause a recovery of the network from partition. Additionally, the network’s ability to accurately measure time means that we can dynamically modify the <em>speed </em>at which validators are unstaked, changing how quickly the network recovers from different types of partitions and how costly we want DDOS attacks to be in relation to how risky we want verification to be. This gets us our <em>dynamic thresholds.</em></p><p>Finally, when a generator is found to be incorrect, either through publishing a false system state or two different system states for one timestep, there are two possible paths for succession — either there is a Secondary generator already chosen (who can be voted on at any time during the current generator’s tenure) who then smoothly slots into power, or there is no secondary generator in which case an immediate phase of voting for a new generator from the verifiers is triggered. Either of these cases takes only as much time as a new block of transmissions, and thus the overall process enables <em>clean transitions </em>— the final necessary property of the intuitive system.</p><p>That’s the overall picture of the <em>consensus </em>extension of PoH, the second piece of Solana. There are, of course, potential issues with this system, which will be discussed in section 5. However, we must now proceed to discuss the last piece of this system (barring smart contract support) — how do we store all this information?</p><p><strong>Section 4: Proofs of Replication: Doesn’t this system take up a lot of space?</strong></p><p>So, now we’ve constructed the entire system, both the transaction and event ordering mechanism of PoH and the consensus and validation mechanism of PoS — all we need now is some way to incentivize people to store the system state and a clean way to prove they’ve done so for rewards. This system would, ideally, contain two parts: some way to represent the network’s state that ensures that it must be stored continuously and sequentially, and a clean, fast way to check that that representation is accurate.</p><p>Let’s now go into how Solana does each of those pieces. First, the state representation: Solana uses what’s called a stream cipher: a type of encryption method that uses the key to generate an “initial text”, then generates each new ciphertext out of the prior text and the input data. Though this is normally used as a way to encode information (hence the name), if you publish the key this method can <em>also </em>serve to prove that you have access to every block as long as the streams are all correct. This provides us our assurance that nodes are storing the entire system continuously and in the correct order.</p><p>Of course, we don’t want to be transmitting entire blocks multiple times back and forth through the system whenever any validator wants to check the work of a replicator. Instead, Solana uses a merkle tree structure, where every block has random bytes selected from it, has those bytes hashed, then combined with the hash of the PoH state that served as the block’s encryption key, then rehashed. This rehash is then combined and hashed with each new block’s rehash to create the ‘root’ of the hash tree — that way, all it takes to validate the block storage is the transfer of these few hashes and the relevant bytes rather than the transfer of entire blocks. Additionally, these proofs can be cheaply verified in parallel as they’re based on parallelizeable hashes and relatively cheap CBC stream encryption.</p><p><strong>Section 5: Putting it all together: Proofs of History in the real world:</strong></p><p>So, we’ve now constructed the entirety of the Solana system (as it stands — various parts of the system are still being fine-tuned and developed). What have we observed? Let’s rehash. Proof of history: a system based around <em>verifiable passage of time, </em>serves as the basis for event ordering and a method to avoid transactional spam. Proof of stake based on a tree structure verification serves as the consensus mechanism. Finally, the system state is stored and verified via a fast, stream cipher based proof of replication. All these pieces should combine to produce a system with incredibly fast finality times — fast enough that the limiting factor for transactions per second is almost just the network’s transaction speed (the source of the 710,000 kbps number, as each transaction under Solana is 176 bytes and the connection is assumed to be 1 gbps). This system looks, of course, very good on paper. But how well does it hold up to potential threats? The paper covers a number of attacks and their defenses, but how about against ones they may not have considered? (NOTE: The tech is, of course, in active development — and I have been discussing these, as have others, with the team).</p><p>The answer? As far as I can tell, pretty well — though there are some potential hiccups I could see happening once the tech is rolled out into the wild.</p><p>Threats to PoH: Not many — the only real threat I could see happening is somebody developing a 10–15% faster hash circuit/algorithm and then getting fast enough to outpace the other verifiers and generate fake histories. If hashing is pretty near optimized, which the current incentives seem to point to, this threat isn’t a strong risk.</p><p>Threats to Consensus model: The incentives in this model still need to be worked out, primarily. If they’re worked out badly, you could end up with, for example, modified 51% attacks where 51% of stakers collaborate to share generation among themselves to maximize the profit share between them, a relatively simple proposition with minimal loss to agreeing verifiers. Similarly, under the current system, the only incentive of the generator to provide false proofs to avoid tragedies of the commons where verifiers blindly vote for single histories is the goodness of his heart — not a strong motivator for one who stands to lose out on generation rewards.</p><p>Additionally, the Avalanche tree system loses out on a lot of redundancy as the loss of any one node requires costly gossip protocols to recover the state from — while Erasure coding (a method for redundantly encoding information) solves some of the redundancy problem, it causes space and thus speed losses. Additionally, even with erasure coding on system states, the tree structure still allows for cheaper DDOS on the network than would otherwise be needed — especially since all it takes is a brief flicker of one node to slow down all the verifiers beneath it on the tree.</p><p>Threats to Replication model: The first block of each key rotation cannot be proven to be stored securely, as proofs can be simply generated on demand. Additionally, replicators can store entire states temporarily, only erasing bytes <em>after </em>new encryption/randomness keys are published, by reasoning that the older the state the less likely it is to be requested. (since, at each round, constant bytes are requested given the constant randomness seeds for the proof). Additionally, the solution to replicator collusion with a generator who seeds the hash for specific proof requirements given in the white paper is, while accurate, unconvincing — given the cheapness of generating specific hashes, there is no reason for the generator not to work for marginal gains (this problem is, in fact, precisely isomorphic to the bitcoin mining problem — and we’ve seen just how far people will go for <em>those </em>marginal rewards).</p><p>All in all I think this project is doing <em>excellent </em>technical work, reservations notwithstanding. I look forward to what they’ll improve about Solana’s system in the coming weeks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d2a6b434649" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Introduction]]></title>
            <link>https://medium.com/@leor.fishman/an-introduction-3ef5a2a8f6c0?source=rss-972066c6ca0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ef5a2a8f6c0</guid>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[The Crypto Realist]]></dc:creator>
            <pubDate>Sun, 03 Jun 2018 17:26:37 GMT</pubDate>
            <atom:updated>2018-06-03T17:59:02.188Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello —</p><p>My name is Leor Fishman, I’m a CS major at Harvard, and I aim to bring a new level of perspective and intuitive understanding to the cryptographic space. Over the past few years, countless people have constructed countless explanations of the fundamentals of blockchain technology — what one is, how it works, and why it matters. These explanations are good but lacking. They do, to be sure, give a good understanding of what the fundamental technologies behind blockchains are, and how they work. And, in 2014, that might have been enough. However, as more and more of those fundamental techs are obsoleted by new innovations, new frameworks and new abstractions, that knowledge rapidly becomes less and less useful. The model of blockchain projects as<em> extensions</em> of Satoshi’s original build has become worse than useless.</p><p>In order to stay current, one has two choices: 1) The <em>comparative</em> approach: graft on pieces to one’s model of blockchains, consistently analyzing projects by comparison to other projects and their services. This is the path most people take, and while it is relatively intellectually cheap and mostly correct, it leads to failures of understanding and, more importantly, a lack of intuition about what projects can and cannot accomplish. This is not a sustainable path. Instead, I propose 2) The <em>fundamental</em> approach: instead of grafting on additional pieces to an inaccurate model, instead construct new intuitive models for each new project. This does require a larger time investment — instead of analyzing projects from the perspective of the provided service, or in comparison to previous or contemporaneous projects, I will be diving into the theoretical underpinnings of each project on <em>their own terms </em>— building a model of their security environment, their perceived threats, and the problem they are trying to solve. Only then will I hone in on their solution, analyzing why it works within the model or why it fails, and what it’s strengths and weaknesses are. Finally, I will examine the model’s <em>completeness</em> — whether there are threats I feel the model doesn’t consider.</p><p>This will not be an ICO review blog for those who want simple, one and done analyses of a project’s team and value proposition — there are several excellent sources for that sort of thing already. This will be a blog for those who want to dive deeply into the technologies of innovative projects, who want to explore how crypto projects might fail just as much as how they succeed, and for those who want to deeply <em>grok</em> how the technologies they plan to invest in work.</p><p>Well, enough introductions. Let’s go break open some projects.</p><p>EDIT: On the advice of a few friends, I’ve also made a telegram for discussion relevant to what I talk about here as well as more general crypto conversations, at <a href="https://t.me/joinchat/GywyMhAZB_c0diDxs6_zhA">https://t.me/</a>TCRgroup1 .</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ef5a2a8f6c0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>