QmV3aWpzIHZhbiB3ZXJrIHZlcnN1cyBiZXdpanMgdmFuIGluemV0OiB3ZWxrZSBpcyBiZXRlcj8=

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 De meest populaire blockchain consensusmechanismen zijn proof-of-work en proof-of-stake.</p>
<p>🔹 Met het proof-of-work consensusmechanisme moeten de validators complexe wiskundige problemen oplossen om de transacties te verifiëren.</p>
<p>🔹 Het proof-of-stake mechanisme vereist dat validators een minimumbedrag van hun inheemse cryptocurrencies inzetten.</p>
<p>🔹 Het is erg moeilijk om te zeggen welke beter is, het proof-of-stake of het proof-of-work consensusmechanisme, aangezien ze beide voor- en nadelen hebben.</p>
<h2 id="h2-Introductie875962"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de traditionele financiële sector registreren banken en andere financiële instellingen handmatig alle transacties. In de meeste glen gebruiken ze softwareprogramma’s om de benodigde gegevens vast te leggen.</p>
<p>Echter, op de blockchain verifiëren en registreren geautomatiseerde en alle transacties. De twee belangrijkste en voor het valideren en registreren van transacties die plaatsvinden op de blockchain zijn proof-of-work en proof-of-stake consensus en.</p>
<p>De <a href="https://www.gate.io/learn/articles/what-is-proof-of-work/63" target="_blank">proof-of-work</a> consensusmechanisme (PoW) gebruikt rekenkracht om complexe cryptografische vergelijkingen op te lossen om alle transacties te verifiëren. Het proces van het oplossen van complexe wiskundige problemen om transacties te valideren wordt cryptomining genoemd en resulteert in de productie van nieuwe munten of tokens.</p>
<p>De mijnwerkers die wiskundige problemen succesvol oplossen, krijgen beloningen in de vorm van de inheemse token of munt van de blockchain. Bijvoorbeeld, mijnwerkers op de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blockchain krijgen hun beloning in de vorm van BTC.</p>
<p>Daarentegen gebruikt het proof-of-stake (PoS) consensus mechanisme validators die grote hoeveelheden gestaakte tokens bezitten om alle transacties te verifiëren. Bijvoorbeeld, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain maakt gebruik van het bewijs van bezit consensusmechanisme, waarbij de validators hun ETH moeten inzetten. Crypto staking is in feite een proces waarbij cryptocurrency wordt ingezet of vergrendeld om te zorgen voor het vastleggen van accurate informatie op de blockchain. In ruil daarvoor verdienen de validators een beloning in de vorm van de native token of munt van de blockchain.</p>
<h2 id="h2-Begrijpen20van20het20consensusmechanisme5326"><a name="Begrijpen van het consensusmechanisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrijpen van het consensusmechanisme</h2><p>Succesvolle blockchains vertrouwen op veilige en betrouwbare consensusmechanismen. Een consensusmechanisme is in feite een manier waarop een enkele waarheid wordt vastgesteld op een blockchain zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. De partijen die belast zijn met het verifiëren van transacties zijn het erover eens dat de gegevens juist zijn en leggen deze vast op de blockchain.</p>
<h2 id="h2-Wat20is20het20proof20of20work20consensusmechanisme120225"><a name="Wat is het proof of work consensusmechanisme?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het proof of work consensusmechanisme?</h2><p>De <a href="https://www.gate.io/bitwiki/detail/150/consensus-algorithm" target="_blank">bewijs van werk consensus</a> mechanismen, aangenomen door <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, beveiligt miljarden dollars aan cryptocurrencies. Zoals eerder vermeld, houdt deze methode in dat complexe wiskundige problemen worden opgelost als een manier om de transacties te verifiëren die plaatsvinden op de blockchain.</p>
<p>De computers of knooppunten die de wiskundige puzzels oplossen, worden mijnwerkers genoemd. Ook de proof of work consensusmechanismen omvatten algoritmes die zijn ontworpen om transacties te valideren en aan de blockchain toe te voegen.<br><img src="https://gimg2.gateimg.com/image/article/1673855204111.png" alt=""></p>
<p>Bewijs van werk consensusmechanisme - Raincom</p>
<p>Een mijnwerker die het probleem oplost, voegt een nieuw blok toe aan het netwerk en verdient daarvoor een beloning. Het is belangrijk op te merken dat de mijnwerkers gespecialiseerde machines zijn met enorme rekenkrachten. Momenteel zijn de application-specific integrated circuits (ASIC’s) de beste mijnwerkers in de sector. Het punt is dat we geen cryptocurrencies kunnen delven met onze gewone computeren.</p>
<p>Het proces om de cryptografische puzzels op te lossen vereist veel elektriciteit, rekenkracht en kost veel tijd. Dit brengt ook andere kosten met zich mee, zoals de algemene infrastructuur, koelen en mankracht. Bovendien is er intense concurrentie om wiskundige problemen op te lossen.</p>
<p>Vanwege de moeilijkheden en kosten die gepaard gaan met crypto mining, belonen blockchains de mijnwerkers met cryptocurrency ter waarde van duizenden dollars. Zo wordt bijvoorbeeld voor het toevoegen van een enkel blok aan de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> het netwerk krijgt de investeerder 6,25 BTC.</p>
<h2 id="h2-Proof20of20work20voor20en20nadelen31676"><a name="Proof of work voor- en nadelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Proof of work voor- en nadelen</h2><p><img src="https://gimg2.gateimg.com/image/article/1673855515222.png" alt=""></p>
<h2 id="h2-Wat20is20proof20of20stake20PoS639066"><a name="Wat is proof of stake (PoS)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is proof of stake (PoS)?</h2><p>Proof of Stake is het op een na populairste consensusmechanisme. In feite is PoS gemaakt om de belangrijkste beperkingen van het proof-of-work-mechanisme te overwinnen. De belangrijkste nadelen van PoW zijn een langzame transactiesnelheid en beperkte schaalbaarheid.</p>
<p>Om een netwerkvalidator te worden, moet een investeerder een vereist minimumbedrag van een cryptocurrency inzetten, die fungeert als een borg tegen oneerlijk gedrag. Als een validator een onjuiste transactie goedkeurt, zal de blockchain zijn/haar ingezette cryptocurrency verbranden.</p>
<p>Het netwerk selecteert willekeurig een validator voor een transactie op basis van de hoeveelheid gestaakte cryptocurrency. Het houdt ook rekening met de periode waarin de tokens zijn gestaakt.</p>
<p>De investeerders die niet over het vereiste minimumbedrag beschikken, kunnen deelnemen aan staking pools waar ze gezamenlijk deelnemen aan het transactiidatieproces. <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zijn voorbeelden van blockchains die <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">gebruik het proof-of-stake consensus mechanisme</a>.</p>
<h2 id="h2-Ethereum2020bewijs20van20belang92658"><a name="Ethereum  bewijs van belang" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> bewijs van belang</h2><p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain is een van de netwerken die het proof of stake consensusmechanisme gebruiken. Om een validator te worden, moet men ten minste 32 ETH inzetten. De validator moet ook drie softwareprogramma’s hebben die het validatieproces ondersteunen. Dit zijn een validator, een consensusclient en een uitvoeringsclient.</p>
<p>Overigens, al geruime tijd de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Blockchain gebruikte het proof-of-work-consensusmechanisme tot het in september 2022 werd veranderd in het proof-of-stake-mechanisme. De belangrijkste reden voor deze upgrade was om het energieverbruik van de blockchain te verminderen en de schaalbaarheid te verbeteren. Het is vermeldenswaard dat de functie van consensusmechanismen is om nauwkeurige transacties die op de netwerken plaatsvinden goed te keuren. Ze verschillen echter in de manier waarop de validatieprocessen werken.<br><img src="https://gimg2.gateimg.com/image/article/1673855593333.png" alt=""></p>
<h2 id="h2-Verschil20tussen20proof20of20work20en20proof20of20stake743961"><a name="Verschil tussen proof of work en proof of stake" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verschil tussen proof of work en proof of stake</h2><p><img src="https://gimg2.gateimg.com/image/article/1673855629444.png" alt=""></p>
<p>Proof of work versus proof of stake - Deltaexchange</p>
<p>Nu we de proof of work-consensusmechanisme en proof of stake een hebben besproken, laten we de twee vergelijken.<br><img src="https://gimg2.gateimg.com/image/article/1673855720555.png" alt=""></p>
<h2 id="h2-Wat20is20beter20het20proof20of20work20consensusmechanisme20of20het20proof20of20stake20mechanisme818746"><a name="Wat is beter: het proof of work consensusmechanisme of het proof of stake mechanisme?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is beter: het proof of work consensusmechanisme of het proof of stake mechanisme?</h2><p>De waarheid is dat het proof of work consensusmechanisme en het proof of stake mechanisme elk hun voor- en nadelen hebben. Het is daarom moeilijk om te concluderen dat de ene beter is dan de andere. Laten we echter kort de drie belangrijkste gebieden verkennen die de twee van elkaar onderscheiden.</p>
<h3 id="h3-Mate20van20centralisatie541641"><a name="Mate van centralisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mate van centralisatie</h3><p>In vergelijking daarmee maken blockchains gebruik van <a href="https://ventures.gate.io/ru/learn/articles/what-is-pos-staking/10" target="_blank">proof-of-stake consensusmechanismen lijken te zijn</a> meer gedecentraliseerd dan diegene die afhankelijk zijn van proof-of-work. Het proof of stake mechanisme stelt veel gebruikers in staat om deel te nemen aan de blockchain, aangezien ze elk bedrag aan cryptocurrency kunnen inzetten.</p>
<p>Gebruikers die het minimumbedrag aan cryptocurrency niet kunnen betalen dat nodig is om validators te worden, kunnen zich aansluiten bij staking pools. Het aantal validators voor blockchains die het proof of work consensusmechanisme gebruiken, is relatief klein omdat ze dure mijnbouwapparatuur zoals ASIC’s moeten kopen. Bovendien moeten ze andere kosten maken zoals elektriciteitskosten.</p>
<h3 id="h3-Netwerkveiligheid807926"><a name="Netwerkveiligheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Netwerkveiligheid</h3><p>De kans op een aanval van 51% op blockchains die gebruik maken van het proof of stake consensusmechanisme is kleiner dan die van netwerken die vertrouwen op proof of work. Dit komt omdat er geen economisch voordeel is aan het uitvoeren van de aanval, aangezien de blockchain hun tokens kan verbranden.</p>
<p>Bovendien is het onwaarschijnlijk dat een individu of kleine groep investeerders de vereiste hoeveelheid kan verzamelen om de aanval uit te voeren, omdat er veel investeerders met gestapelde tokens zijn.</p>
<p>In principe is het met het proof of work consensus mechanisme erg lastig voor een paar miners om meer dan 50% van de rekenkracht van een blockchain te beheersen. De aanvallers kunnen echter meer dan 50% van de rekenkracht bereiken van blockchains met kleine marktkapitalisaties.</p>
<h3 id="h3-Energieverbruik46519"><a name="Energieverbruik" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Energieverbruik</h3><p>Het delven van cryptocurrency verbruikt veel energie, waardoor het erg duur is. Technisch gezien verbruikt de rekenkracht die nodig is om het cryptografische raadsel op te lossen veel elektriciteit. Daarom voeren milieuactivisten campagne tegen crypto mining.<br><img src="https://gimg2.gateimg.com/image/article/1673855807666.png" alt=""></p>
<p>Bewijs van energieverbruik op basis van werk- Thenextweb</p>
<p>Blockchains die gebruikmaken van het consensusmechanisme van proof of stake verbruiken echter niet veel energie. Het voorbeeld <a href="https://www.gate.io/bitwiki/detail/102/ethereum" target="_blank">van de Ethereum blockchain</a> kan dit duidelijk maken. Wanneer de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Toen blockchain overging van het proof of work-mechanisme naar het proof of stake-mechanisme, daalde het elektriciteitsverbruik met 99,9%.</p>
<p>De bovenstaande vergelijking lijkt erop te wijzen dat het proof-of-stake consensusmechanisme beter is dan het proof-of-work mechanisme. Desalniettemin is er meer tijd nodig om met vertrouwen tot zo’n conclusie te komen, aangezien het proof-of-stake consensusmechanisme slechts gedurende een korte periode en op kleinere schaal is getest in vergelijking met het proof-of-work mechanisme.</p>
<h3 id="h3-Conclusie994664"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Er zijn verschillende blockchain-consensusmechanismen aan het werk. De proof-of-work en de proof-of-stake mechanismen zijn echter de meest populaire. Merk op dat het proof-of-work mechanisme cryptomining gebruikt om transacties te verifiëren, terwijl het proof-of-stake mechanisme vertrouwt op validators die een bepaalde hoeveelheid cryptocurrencies inzetten.</p>
<h2 id="h2-Veelgestelde20vragen20over20de20verschillen20tussen20PoW20en20PoS13429"><a name="Veelgestelde vragen over de verschillen tussen PoW en PoS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over de verschillen tussen PoW en PoS</h2><h3 id="h3-Waarom20is20proof20of20work20vereist20voor202020Bitcoin20918955"><a name="Waarom is proof of work vereist voor   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is proof of work vereist voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Bewijs van werk is een consensusmechanisme waarbij validators complexe wiskundige problemen oplossen om transacties te verifiëren en deze aan de blockchain toe te voegen. Het is een bewezen en sterke methode om een blockchainnetwerk te beveiligen zoals de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> netwerk. Het voorkomt mogelijke aanvallen van kwaadwillende actoren zoals hackers en voorkomt dubbele uitgaven van BTC.</p>
<h3 id="h3-Hoe20verschilt20proof20of20work20van20proof20of20stake530669"><a name="Hoe verschilt proof of work van proof of stake?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe verschilt proof of work van proof of stake?</h3><p>Het belangrijkste verschil is dat proof of work afhankelijk is van het oplossen van cryptografische vergelijkingen om transacties te valideren en aan een blockchain toe te voegen. In beide glen kan een knooppunt met de hoogste rekenkracht de transactie goedkeuren. Met het proof of stake mechanisme moeten de validators echter een grote hoeveelheid van de inheemse cryptocurrency vergrendelen om transacties op een blockchain te verifiëren. Bovendien is de validator die de grootste hoeveelheid vergrendelde tokens heeft, waarschijnlijk de transactie goed te keuren en toe te voegen aan het netwerk.</p>
<h3 id="h3-Waarom20is20PoS20beter20dan20PoW913068"><a name="Waarom is PoS beter dan PoW?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is PoS beter dan PoW?</h3><p>Ten eerste zijn proof of work en proof of stake vergelijkbaar doordat ze consensusmechanismen zijn die worden gebruikt voor het verifiëren en toevoegen van transacties aan blockchains. Bij PoW gebruiken deelnemers aan het netwerk veel rekenkracht, wat veel energie verbruikt, om transacties te verifiëren. Desalniettemin vereist PoS dat deelnemers aan het netwerk een bepaalde hoeveelheid van de inheemse cryptocurrency op het netwerk vergrendelen om transacties te verifiëren en toe te voegen aan de blockchain. Daarom verbruikt PoS niet zoveel energie als PoW. Bovendien is PoS schaalbaarder, sneller en goedkoper dan PoW.</p>
<h3 id="h3-Does202020Bitcoin2020gebruik20je20proof20of20work20of20proof20of20stake46423"><a name="Does   Bitcoin  gebruik je proof of work of proof of stake?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Does <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> gebruik je proof of work of proof of stake?</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Maakt gebruik van een proof of work-consensusmechanisme waarbij netwerkdeelnemers complexe wiskundige vergelijkingen oplossen om transacties goed te keuren en aan het netwerk toe te voegen. Dit proces waarbij rekenkracht wordt gebruikt om de cryptografische vergelijkingen op te lossen en nieuwe munten te produceren, wordt mining genoemd. In ruil daarvoor beloont de blockchain de eerste node die de vergelijking oplost met 6,25 BTC.</p>
<h3 id="h3-Wat20is20het20verschil20tussen20proof20of20work20en20proofofauthority887343"><a name="Wat is het verschil tussen proof of work en proof-of-authority?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het verschil tussen proof of work en proof-of-authority?</h3><p>Het proof-of-authority-consensusmechanisme wijst de rol van validators toe aan een klein aantal netwerkdeelnemers. Met het proof-of-work-mechanisme gebruiken de validators echter hun rekenkracht om complexe wiskundige problemen op te lossen als middel om de transacties te valideren. Aangezien de validators die het proof-of-work-mechanisme gebruiken concurreren om de complexe vergelijking op te lossen, beloont de blockchain alleen degene die de transactie verifieert.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>