<?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 Nikolai Cherkezishvili on Medium]]></title>
        <description><![CDATA[Stories by Nikolai Cherkezishvili on Medium]]></description>
        <link>https://medium.com/@nikche?source=rss-35d43c82bbd8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wp5e1uwjHlI2qEvSpvWgWw.jpeg</url>
            <title>Stories by Nikolai Cherkezishvili on Medium</title>
            <link>https://medium.com/@nikche?source=rss-35d43c82bbd8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 20:00:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nikche/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[Consensus. Part 2. Proof of Randomness]]></title>
            <link>https://nikche.medium.com/consensus-part-2-proof-of-randomness-90876b326205?source=rss-35d43c82bbd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/90876b326205</guid>
            <category><![CDATA[proof-of-randomness]]></category>
            <category><![CDATA[proof-of-work]]></category>
            <category><![CDATA[proof-of-stake]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Nikolai Cherkezishvili]]></dc:creator>
            <pubDate>Thu, 02 Feb 2023 23:22:16 GMT</pubDate>
            <atom:updated>2023-02-02T23:22:16.381Z</atom:updated>
            <content:encoded><![CDATA[<p>Proof of Randomness (PoR) is a goofy name for Proof of Stake (PoS) consensus protocol without staking, or if you imagine that every validator node stakes the same amount of funds, then PoS becomes PoR.</p><p>I intentionally didn’t want to implement PoS, just to keep things simple. After all, adding that last bit which turns PoR into PoS is not a big deal, as long as you have the former in place. In this article I won’t use the term PoR anymore, I’ll just use PoS to keep things more straightforward.</p><p>So, we already covered Proof of Work (PoW) in the last article here <a href="https://nikche.medium.com/consensus-pow-pos-po-7896c73374ec">https://nikche.medium.com/consensus-pow-pos-po-7896c73374ec</a>.</p><p>Proof of Stake is very different from Proof of Work conceptually. It has completely different consensus protocol. In my opinion PoS is more complex than PoW, but it has benefits.</p><p><strong>The most obvious benefits of PoS are: <br></strong>1. less energy consumption (lower price)<br>2. adding new block requires less time (higher throughput)</p><p><strong>On the negative side</strong> (<em>This is my personal opinion</em>) I can only point out that PoW is just more natural for blockchain, because it’s much easier to design and implement. PoW can be implemented with less moving parts, with less coordination between nodes, therefore it’s less complex, more robust and as a result it’s more hacker proof. Again, this is my personal opinion, if you have a different experience I’d be happy to learn about it. I’ll cover it more in the following chapter.</p><h3>Proof of Work vs Proof of Stake</h3><p>These two consensus algorithms are very different. But if you ask me what’s the biggest and most crucial difference, I’d say it’s the quorum part. When dealing with PoW, the concept of quorum is naturally follows from the combined computational power. Thus, you don’t really need to think about quorum as such. The majority will always win, the rogue nodes stand no chance. If the rogue node gets lucky and wins agains the computational quorum, it means nothing, because the chances of the same rogue node winning the next round become even thinner. So getting the 2nd confirmation is very unlikely.</p><p>Let’s have a look at proof of stake now. There is no computational effort involved, which means that we have to think about quorum ourselves now, because if we don’t, it’s gonna be very easy to steal the tip of the blockchain, then do a second fake confirmation, and then another one and so on.</p><p>From my experience of working on the blockchain project, this is the biggest difference between PoW and PoS. This is why these two approaches will be so different from a design perspective. By writing this I also wanted to point out how natural and elegant the PoW solution for blockchain is.</p><h3>Proof of Stake</h3><p>I came up with at least 3 different implementations of PoS, the trick was to come up with something simple yet robust. I’m going to describe a method which I chose for my blockchain (<a href="https://github.com/cnnickolay/rust_blockchain_engine">https://github.com/cnnickolay/rust_blockchain_engine</a>).</p><p>Every block is a sum type of 2 possible structs: Transactions and Timestamp.</p><pre>struct Transactions {<br>  transactions: Vec&lt;SignedBalancedTransaction&gt;<br>}<br>struct Timestamp {<br>  timestamp: ...,<br>  owner: PublicKey,<br>  // votes are coming from the other nodes which recognise the owner<br>  votes: Vec&lt;Signature&gt;<br>}<br>enum Block {<br>  _Transactions(Transactions),<br>  _Timestamp(Timestamp)<br>}</pre><figure><img alt="A very high level design of the block" src="https://cdn-images-1.medium.com/max/1024/1*L7KZhSCeGVjAkoJRj8DH4Q.png" /><figcaption>A very high level design of the block</figcaption></figure><p>Timestamp and Transaction blocks almost always go in pair, e.g.</p><pre>blockchain = [<br>  timestamp-1,<br>  transactions-1,<br>  timestamp-2,<br>  transactions-2,<br>  timestamp-3,<br>  transactions-3,<br>  ...<br>]</pre><p>This is done with a purpose. Timestamp block is a result of entire network electing which validator is going to be the next owner of the transactions block and will receive a reward. After the next timestamp block successfully mined, the elected validator has some grace period for which it should propagate its mined block back to the network. If it fails to do that in time, the next timestamp block will follow with another leader elected.</p><p>So, the following situation is possible if elected validator was offline or failed to propagate its block to the network:</p><pre>blockchain =[<br>  timestamp-1,<br>  transactions-1,<br>  timestamp-2,<br>  timestamp-3,<br>  transactions-3,<br>  ...<br>]</pre><h3>Electing the block owner</h3><p>The election of the validator which is going to be the owner of the next block is done with so called <strong>Shout</strong> message. Every validator of the network Shouts (broadcasts its Shout message into the network) and gets a reply. The doodle below illustrates the idea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vYGip0zTdQd7-5D97_YodA.jpeg" /><figcaption>Every node is “shouting” into the network</figcaption></figure><p>The purpose of Shout is 1) to let the entire network know that I’m as a validator is up and running and ready to take part in the elections campaign and 2) propagate its vote to the winning validator.</p><p>Every validator can determine the winner by using <em>determine_the_winner</em> function you can find below. So if you’re wondering why to Shout if every validator can find out the owner of the next block? After all, it’s a deterministic process, and it’s easy to do that calculation because all validators are aware of each other. Well, some validators can be offline, if you’re offline you can’t be elected as a block owner. So it’s not just determining the winner, it’s also about finding the leader which is online now and is able to mine the next block.</p><p><strong>Now, a very important moment. </strong>As you may have guessed, just shouting “I’m here” is not enough to decide who’s gonna be the winner. Moreover, there is a moment of randomness involved in deciding who’s the winner. I use the following formula to determine the next block owner:</p><pre>// rust-y pseudocode<br>fn determine_the_winner(left_side: &amp;PublicKey, <br>                        right_side: &amp;PublicKey, <br>                        blockchain_tip_hash: &amp;str) -&gt; PublicKey {<br>  let mut left_val = String::new();<br>  left_val.push_str(left_side.to_string());<br>  left_val.push_str(blockchain_tip_hash);<br><br>  let right_val = String::new();<br>  right_val.push_str(right_val.to_string());<br>  right_val.push_str(blockchain_tip_hash);<br><br>  if hash(left_val) &gt; hash(right_val) {<br>    left_val<br>  } else {<br>    right_val<br>  }<br>}</pre><p>By running the function above entire network gets to the consensus on which validator is the owner of the next block. The source of randomness comes from blockchain_tip_hash and PublicKey of the validators.</p><p>Why can’t we use the rand() function for a source of randomness? Because determine_the_winner() has to be a pure function, it should always return same outputs given same inputs. It has to be verifiable by any node of the network in any moment of time. For that, we need to exclude any source of randomness.</p><p><strong>Note</strong>. In current implementation there is no staking involved, therefore it’s just Proof of Randomness, not the Proof of Stake. But if you want to add staking, just modify this function to consider the weight of every validator when deciding who’s gonna be the winner and add a rewarding transaction into the mined block.</p><h3>Mining the block</h3><p>After the election campaign some real work should follow. This is the easiest part actually, because mining a block in PoS is nothing but putting a bunch of transactions from a mempool into a single basket, signing it and propagating it back to voters. Don’t forget to put a rewarding transaction for yourself if it’s a PoS consensus. But for PoR we don’t need that.</p><h3>PoR in a single diagram</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6yzdfS-zhasgQ00gJeJIeA.png" /><figcaption>Sequence flow demonstrates how PoS (PoR) works</figcaption></figure><p>Explanation of the diagram:<br>1. User 1 and User 2 send their signed and balanced transactions into the MemPool.<br>2. Validators propagate their Shout messages over the network. They use determine_the_winner function to decide who’s going to be the one. It works just like the fold_left function in Scala or foldl in Haskell. If you apply this function to every node of the network, only one will remain eventually. The losing validator should also pass its signature to the winning validator, it’s necessary for resolving disputes. Imagine a situation when a node which could be a winner for a block was offline, and then comes by and tries to pull the blanket and put the blockchain tip to its own favour. For that not to happen, block should have votes in the form of digital signatures associated with them. Those votes will prove that the miner of the block was online when the block was mined. That excludes the possibility of rewriting the history.<br>3. When entire network is synchronised and the winner is established, the next block can be mined and propagated to the network.</p><h3>Why Proof of Randomness is not a viable solution</h3><p>To become a truly ultimate consensus solution PoR will need to morph into PoS. I use PoR just because it’s more simple than PoS, so it’s better suited for a training project.</p><p>But why it can’t be used in the real world solutions. Let’s say we don’t care about rewarding our nodes for block mining, they are completely altruistic.</p><p>In a consensus scenario where network consists of unreliable nodes, you’ll need some stake from those nodes to avoid “spawn a thousand nodes” type of attack. See, when nodes don’t stake anything it’s very easy to overrun the network with &gt;50% attack. In PoW consensus the stake is computing power of a node. In PoS the stake is the currency of the blockchain network. In PoR there is no stake, thus, anyone can see how many nodes in the current network configuration and just spawn a N/2+1 more nodes for a short period of time, where N is the size of network.</p><p>To safeguard the network from this some sort of stake is needed. So don’t use PoR in unreliable networks.</p><h3>Disclaimer</h3><p>This article is the author’s vision on how Proof of Stake can be implemented. Unlike PoW there are multiple ways to design it. I’m sure there are flaws, which I’ll point out when it gets to implementation.</p><p>Other articles: <br><a href="https://nikche.medium.com/reinventing-the-blockchain-1294677f7ad4">https://nikche.medium.com/reinventing-the-blockchain-1294677f7ad4</a><br><a href="https://nikche.medium.com/consensus-pow-pos-po-7896c73374ec">https://nikche.medium.com/consensus-pow-pos-po-7896c73374ec</a></p><p>The project itself is here: <a href="https://github.com/cnnickolay/rust_blockchain_engine/tree/refs/tags/milestone-1">https://github.com/cnnickolay/rust_blockchain_engine/tree/refs/tags/milestone-1</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90876b326205" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Consensus! Part 1 (PoW, PoS, Po….)]]></title>
            <link>https://nikche.medium.com/consensus-pow-pos-po-7896c73374ec?source=rss-35d43c82bbd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/7896c73374ec</guid>
            <category><![CDATA[consensus]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[proof-of-work]]></category>
            <dc:creator><![CDATA[Nikolai Cherkezishvili]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 23:54:20 GMT</pubDate>
            <atom:updated>2023-02-02T23:23:09.801Z</atom:updated>
            <content:encoded><![CDATA[<p>In my experience this is the most interesting and challenging part in Blockchain ecosystem. Before I start this chapter, let me make one statement. Consensus algorithm has no perfect solution. You can improve it endlessly, make it more robust, but it will never be perfect. There will always be certain conditions, which may trigger a hard fork (the worst nightmare of any blockchainer).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*uN1n0uiNWQ2Wn-jTjU2OAg.jpeg" /></figure><h4>Let us agree on what the truth is</h4><p>Consensus is about deciding what is the truth. In centralised apps world it’s very easy. If our database is protected by VPN, passwords and layers of security, it’s very simple. The truth is reflected in the state of our database. That’s it. If database was compromised, security breached, then the source of truth is compromised too.</p><p>What about decentralised environments? There is no single source of truth, every node has its own truth. If most of the nodes (&gt;50%) agree on something, this is the truth! How to make those nodes agree on something? Can’t be easier isn’t it? Or is it?</p><p>Let’s consider a trivial implementation of consensus algo. Every node has equal voting weight. The source of truth is decided by the majority votes. Image below illustrates that 6 nodes are trying to reach consensus. Number 1 wins by the majority of votes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*gXlKusmWLDoKU-PSbyRHTw.jpeg" /><figcaption>Consensus by the majority of commonly accepted truth</figcaption></figure><p>So finding the truth by majority of votes is pretty obvious solution. And it may work for a while, but up to a point when someone decides to alter your blockchain program to produce the truth that they want, then spins up a certain amount of nodes to make it the majority in the network, and alter the source of truth in a desired way.</p><p>Let’s think how we can seal that loophole once and for all.</p><h4>Proof of work</h4><p>Proof of work is a beautiful way to solve this problem, or maybe I should say, to boost the complexity of altering the truth so high that nobody in this world has enough resources to pull it off.</p><p>Let’s make one step back. Before, I said that the truth is established by the majority of the votes. Now, only one node gets to decide what is the truth, but the rest will have to agree on that. In order to do that, this node has to solve some mathematical problem which may take a very significant effort. When this lucky node finds a solution, it offers it to the network. If other nodes accept it they’ll start solving the next problem based on this new “truth” the other node proposed. This process goes on endlessly.</p><p>Let’s see why this approach is more stable than the previous one with the majority of votes.</p><p>Imagine if you want to take over the network and alter the truth in the way you want (say, put more zeroes in your wallet), you’ll need to build an alternative network, which will have combined computational capacities large enough to compete with existing network. This problem becomes so hard that nobody in the world can pull it off.</p><p>But what if some rogue organisation with only 1 laptop decides to try, and against all odds it solves that problem and manages to alter the truth? Here is what’s gonna happen next. The rest of the network won’t accept that version of truth and will keep looking for its own solution. When it finds it, we’ll have 2 heads in our blockchain (i.e. 2 truths). Now, how to decide which head is the right one? There is no way really, and don’t worry about it. Because those 2 different heads will keep living their own lives, until one of them gets appended by the next block. When it happens, this 2-truths nonsense will be neutralised in favour of the longest chain after the fork. Do you think that single laptop rogue organisation gets lucky twice in a row? Unlikely. Three times in a row? Even more unlikely.</p><p>The picture below illustrates this case when we suddenly have 2 different sources of truth. You can see that after block N our ledger got forked and now it has 2 heads: N+1 and N’+1. But we don’t panic. The next block will decide which truth is the right one. The green side of our forked blockchain gets to the next block N+2 first, because it’s a computational power of the entire network against a single rogue laptop. So the orange side has to give up its forked reality in favour of the greens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/346/1*r-HevLIyhgo09GqU0sHpDQ.jpeg" /><figcaption>Blockchain is getting forked and de-forked</figcaption></figure><p>If you ever transacted cryptocurrencies you may remember that the party to which you’re sending your money always has this sort of condition “We’ll accept your transaction after 2 (10, 20, etc.) confirmations”. This is exactly what it’s about. The more blocks get piled up on top of the block with your transaction, the less chance that the blockchain will be de-forked in favour of some other parallel block (another source of truth), thus making your payment vanish. This is exactly why no merchant will accept your payment with only 1 confirmation. Imagine if your payment ended up in Block N’+1 (see the picture above), and when the next block comes they realise that transaction is gone, but they already delivered what you were buying from them.</p><p><strong>To clarify more about confirmations.</strong> Having two confirmations for a transaction means that there is another block already found on top of the block with your transaction. 10 confirmations means that there are 10 blocks and so on. The more confirmations you get, the less likely that your transaction will be gone as a result of blockchain de-forking.</p><p><strong>No solution is perfect</strong></p><p>As I said in the beginning, there is no perfect consensus algorithm. All you can do is to increase the complexity of hacking your network so much that this task becomes next to impossible.</p><p>Proof of work solves this problem, but introduces few others, i.e. network becomes slow and requires really advanced hardware, which in turn consumes a lot of energy.</p><p>In the next article I’ll cover Proof of Stake consensus algorithm, and will try to come up with implementation for it.</p><p><a href="https://nikche.medium.com/reinventing-the-blockchain-1294677f7ad4">https://nikche.medium.com/reinventing-the-blockchain-1294677f7ad4</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7896c73374ec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blockchain: why UTxO is important]]></title>
            <link>https://nikche.medium.com/a-couple-of-words-about-utxo-5a97bac8fe00?source=rss-35d43c82bbd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a97bac8fe00</guid>
            <category><![CDATA[double-spending]]></category>
            <category><![CDATA[utxo]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Nikolai Cherkezishvili]]></dc:creator>
            <pubDate>Sun, 22 Jan 2023 10:01:04 GMT</pubDate>
            <atom:updated>2023-02-01T20:41:40.855Z</atom:updated>
            <content:encoded><![CDATA[<p>UTxO is one of the central elements in any cryptocurrency. The idea behind UTxO is that you know exactly where funds are coming from, not just from which wallet, but from which transactions. Every transaction becomes backtraceable to the very first block. This solves a huge problem or any financial instrument, the double spending problem.</p><p>But in my blockchain there was no place for UTxO, … initially…</p><h4>No UTxO</h4><p>First implementation of my blockchain engine was really simple. I didn’t plan to use any UTxO, my transaction was looking like this:</p><pre>struct Transaction {<br>  sender: PublicKey,<br>  receiver: PublicKey,<br>  amount: u64,<br>  signature_by_sender: String<br>}</pre><p>What can be more simple, right? This system worked, but there was one problem.</p><p>Imagine if computer program glitched during sending a transaction and sent the same transaction twice. There is no way for the validator node to tell if it was intended to be like that, or it was a glitch.</p><p>Or, another situation. Imagine that party A created a transaction to transfer some funds to party B and signed it. Party B then will be able to submit the same transaction to the blockchain many times, because there is no indication whether this transaction is already in the blockchain. The signature means that the transaction was approved by A, so what can stop B from sending this transaction over and over again to the blockchain?</p><p>This is a problem of double spending.</p><h4>Here comes the NONCE</h4><p>At first I introduced something that is known in web3, the NONCE. I included nonce in the transaction. It was needed to be some unique string, e.g. UUID, and the sender would have to sign that nonce (together with entire transaction).</p><pre>struct Transaction {<br>  nonce: String,<br>  sender: PublicKey,<br>  receiver: PublicKey,<br>  amount: u64,<br>  signature_by_sender: String<br>}</pre><p>Much better now, because now there is no way to double spend the same funds. Of course validator nodes would have to check if this nonce already existed on the blockchain, and if it was, it would reject the transaction.</p><h4>Here comes the UTxO</h4><p>But there is a much better, incredibely elegant solution, which is utilised by Bitcoin and pretty much any cryptocurrency in one way or another. Instead of storing how much funds each wallet has, we can store a list of UTxOs associated with every wallet on the ledger. This is how it may look.</p><pre>struct Utxo {<br>  address: String, // unique string identifying UTxO in the blockchain<br>  amount: u64,<br>  address: PublicKey,<br>}<br><br>struct Transaction {<br>  input_utxos: Vec&lt;Utxo&gt;,<br>  output_utxos: Vec&lt;Utxo&gt;,<br>  signature: String<br>}</pre><p>So, what changed? A lot! As you can see there is no sender and receiver now in the transaction, and no amount. All this data now is encapsulated now in utxos.</p><p>Two important things about UTxO:</p><ol><li>Once a UTxO appears at some transaction’s input, it’s considered spent, and it can’t be spent again.</li><li>UTxO can’t be spent partially, only entirely. Which means that if you have $100 in your UTxO, you will spend that entire amount. You may be wondering now, what if someone want to send only $10, but they have only one UTxO with $100. In this case transaction will have to contain another UTxO listed in output_utxos, containing change amount for the sender.</li></ol><p>To get better understanding have a closer look at the following example. Keep in mind that A wants to transfer only $10 to B.</p><pre>{<br>  &quot;input_utxos&quot;: [<br>    {<br>      &quot;amount&quot;: 100,<br>      &quot;public_key&quot;: &quot;A&quot;,<br>    }<br>  ],<br>&quot;output_utxos&quot;: [<br>    {<br>      &quot;amount&quot;: 10,<br>      &quot;public_key&quot;: &quot;B&quot;,<br>    },<br>    {<br>      &quot;amount&quot;: 90,<br>      &quot;public_key&quot;: &quot;A&quot;,<br>    },<br>  ],<br>  &quot;signature&quot;: &quot;signature by A&quot;<br>}</pre><p>It may look strage why A has $100 at input when it wants to transfer only $10. But if you look at the output UTxOs, you’ll notice that the second UTxO has $90 change. So if we sum up inputs and outputs, it’s gonna be like this</p><pre>A: -$100 + $90 = -$10  // A pays $10 as was intended<br>B: +$10                // B receives $10<br>Total: -$10 + $10 = $0 // Transaction is correctly, because saldo is 0</pre><p>Here goes another rule. If you sum up all the UTxOs in a single transaction you should get 0. Unless you want to include transaction validation fee as a reward or something. Then transaction may have another output UTxO with validator node address listed in it.</p><p>Needless to say that transaction should be signed by all parties listed in the input UTxOs. In my version of blockchain a single transaction can have only one party in the input UTxOs. I did it for simplicity reasons, but there are no limits. If you want to support a multi sender transactions, just include many signatures, so that each sending party could sign that transaction.</p><p>This is how I implemented UTxO and transaction in my blockchain.</p><ul><li><a href="https://github.com/cnnickolay/rust_blockchain_engine/blob/refs/tags/milestone-1/engine/src/blockchain/utxo.rs">rust_blockchain_engine/utxo.rs at refs/tags/milestone-1 · cnnickolay/rust_blockchain_engine</a></li><li><a href="https://github.com/cnnickolay/rust_blockchain_engine/blob/refs/tags/milestone-1/engine/src/blockchain/balanced_transaction.rs">rust_blockchain_engine/balanced_transaction.rs at refs/tags/milestone-1 · cnnickolay/rust_blockchain_engine</a></li></ul><p>Now you may ask what the heck is <strong>balanced</strong> transaction. This will come soon in one of the next articles.</p><h4>Conclusion</h4><p>By now you should see how using UTxO solves the problem of double spending, and also gives incredible traceability of the funds.</p><p>My previous article can be found here: <a href="https://medium.com/@nikche/reinventing-the-blockchain-1294677f7ad4">https://medium.com/@nikche/reinventing-the-blockchain-1294677f7ad4</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a97bac8fe00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reinventing the Blockchain]]></title>
            <link>https://nikche.medium.com/reinventing-the-blockchain-1294677f7ad4?source=rss-35d43c82bbd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/1294677f7ad4</guid>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Nikolai Cherkezishvili]]></dc:creator>
            <pubDate>Thu, 19 Jan 2023 23:39:44 GMT</pubDate>
            <atom:updated>2023-01-19T23:39:44.233Z</atom:updated>
            <content:encoded><![CDATA[<p>Some time ago I decided to learn programming language Rust. Learning a new language always better by making your own project from scratch, this project should be interesting enough to keep you motivated. Reading books helps, but is not sufficient, because books lack for a practical aspect.</p><p>So I decided to make my own project, I chose to make blockchain platform from scratch. Why blockchain? Because it’s challenging and interesting enough to keep me going and it would allow me to cover most aspects of Rust. Blockchain covers such areas as distributed ledger, cryptography, hashing, consensus algorithms and other.</p><p>Initially I didn’t think about making a crypto currency. I wanted something like a decentralised store of documents for authenticity verification, or something else that would make Blockchain useful in the area other than financial transaction. But then I realised that crypto currency is a great first step in learning Blockchain in-depth, because you don’t need to spend your time inventing a good idea for your block chain platform first, it’s already there, just transacting between wallets.</p><p>So it was all set, I started writing my own blockchain from scratch. By the time I decided to write this article I already spent one month contributing to the project every day for a month. With a lot of rewrites, caused by constantly improving understanding of Rust and Blockchain, here is my code as of 20th Jan 2023.</p><p><a href="https://github.com/cnnickolay/rust_blockchain_engine/tree/refs/tags/milestone-1">GitHub - cnnickolay/rust_blockchain_engine at refs/tags/milestone-1</a></p><p>Many may find a lot of controversial ideas and implementations in this project, but this is purely educational project at this moment. What I wanted to avoid is reimplementing existing blockchain platforms, that is why many aspects of my own implementation may seem unual. But please, stay tuned, there will be more :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1294677f7ad4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>