UHJvb2Ytb2Ytd29yayB2cyBQcm9vZi1vZi1TdGFrZTogcXVhbGUgw6ggbWlnbGlvcmU/

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 I meccanismi di consenso più popolari della blockchain sono quelli di proof-of-work e proof-of-stake.</p>
<p>🔹 Con il meccanismo di consenso proof-of-work i validatori devono risolvere complessi problemi matematici per verificare le transazioni.</p>
<p>🔹 Il meccanismo di proof-of-stake richiede ai validatori di scommettere una quantità minima delle loro criptovalute native.</p>
<p>🔹 È molto difficile dire quale sia migliore, il meccanismo di consenso proof-of-stake o proof-of-work, poiché entrambi hanno vantaggi e svantaggi.</p>
<h2 id="h2-Introduzione231884"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nel settore finanziario tradizionale le banche e altre istituzioni finanziarie registrano manualmente tutte le transazioni. Nella maggior parte dei casi utilizzano programmi software per acquisire i dati di cui hanno bisogno.</p>
<p>Tuttavia, nei sistemi computerizzati blockchain, vengono verificate e registrate tutte le transazioni. I due principali sistemi per convalidare e registrare le transazioni che si verificano sulla blockchain sono i sistemi di consenso proof-of-work e proof-of-stake.</p>
<p>Il <a href="https://www.gate.io/learn/articles/what-is-proof-of-work/63" target="_blank">prova di lavoro</a> Il meccanismo di consenso (PoW) utilizza la potenza di calcolo per risolvere equazioni crittografiche complesse al fine di verificare tutte le transazioni. Il processo di risoluzione di problemi matematici complessi per convalidare le transazioni è chiamato mining di criptovaluta e porta alla produzione di nuove monete o token.</p>
<p>I minatori che risolvono con successo problemi matematici ottengono ricompense sotto forma di token o moneta nativa della blockchain. Ad esempio, i miner sul <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> i minatori di blockchain ottengono la loro ricompensa in forma di BTC.</p>
<p>Al contrario, il meccanismo di consenso del proof-of-stake (PoS) utilizza validatori, che detengono grandi quantità di token bloccati, per verificare tutte le transazioni. Ad esempio, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La blockchain utilizza il meccanismo di consenso proof of stake che richiede ai validatori di bloccare i loro ETH. Fondamentalmente, lo staking delle criptovalute è un processo di vincolare o bloccare la criptovaluta per garantire la registrazione di informazioni accurate sulla blockchain. In cambio, i validatori guadagnano una ricompensa sotto forma di token o moneta nativa della blockchain.</p>
<h2 id="h2-Comprendere20il20meccanismo20di20consenso243584"><a name="Comprendere il meccanismo di consenso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprendere il meccanismo di consenso</h2><p>Le blockchain di successo si basano su meccanismi di consenso sicuri e affidabili. In sostanza, un meccanismo di consenso è un modo per stabilire una singola verità su una blockchain come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Le parti incaricate di verificare le transazioni concordano che i dati siano corretti e li registrano sulla blockchain.</p>
<h2 id="h2-Qual2020il20meccanismo20di20consenso20del20proof20of20work624041"><a name="Qual è il meccanismo di consenso del proof of work?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il meccanismo di consenso del proof of work?</h2><p>Il <a href="https://www.gate.io/bitwiki/detail/150/consensus-algorithm" target="_blank">consenso di proof-of-work</a> meccanismi, adottati da <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, assicura miliardi di dollari di criptovalute. Come precedentemente indicato, questo metodo prevede la risoluzione di complessi problemi matematici come mezzo per verificare le transazioni che avvengono sulla blockchain.</p>
<p>I computer o nodi che risolvono i rompicapo matematici sono chiamati minatori. Anche i meccanismi di consenso della prova del lavoro coinvolgono algoritmi progettati per convalidare le transazioni e aggiungerle alla blockchain.<br><img src="https://gimg2.gateimg.com/image/article/1673855204111.png" alt=""></p>
<p>Meccanismo di consenso di prova del lavoro - Raincom</p>
<p>Un minatore che risolve il problema aggiunge un nuovo blocco alla rete e guadagna una ricompensa per questo. È importante notare che i minatori sono macchine specializzate con enormi potenze di calcolo. Attualmente, i circuiti integrati specifici per applicazioni (ASIC) sono i migliori minatori del settore. Il punto è che non possiamo estrarre criptovalute utilizzando i nostri normali sistemi informatici.</p>
<p>Il processo di risoluzione dei puzzle crittografici richiede molta elettricità, potenza di calcolo e tempo. Ciò comporta anche altre spese relative all’infrastruttura generale, ai sistemi di raffreddamento e alla manodopera. Inoltre, c’è una forte concorrenza per risolvere i problemi matematici.</p>
<p>A causa delle difficoltà e dei costi legati al mining di criptovalute, le blockchain ricompensano i minatori con criptovalute del valore di migliaia di dollari. Ad esempio, per aggiungere un singolo blocco alla <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> nella rete l’investitore ottiene 6,25 BTC.</p>
<h2 id="h2-Vantaggi20e20svantaggi20del20proof20of20work49781"><a name="Vantaggi e svantaggi del proof of work" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vantaggi e svantaggi del proof of work</h2><p><img src="https://gimg2.gateimg.com/image/article/1673855515222.png" alt=""></p>
<h2 id="h2-Cos20la20proof20of20stake20PoS842266"><a name="Cos’è la proof of stake (PoS)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la proof of stake (PoS)?</h2><p>La prova di gioco è il secondo meccanismo di consenso più popolare. Fondamentalmente, il PoS è stato creato per superare le principali limitazioni del meccanismo del proof-of-work. Gli svantaggi principali del PoW sono la lentezza delle transazioni e la limitata scalabilità.</p>
<p>Perché un investitore diventi un validatore di rete, deve scommettere una quantità minima richiesta di una criptovaluta che funge da garanzia contro comportamenti disonesti. Se un validatore approva una transazione incorretta, il blockchain brucerà la sua criptovaluta scommessa.</p>
<p>La rete seleziona casualmente un validatore per una transazione in base all’importo della criptovaluta in gioco. Considera anche il periodo in cui i token sono stati bloccati.</p>
<p>Gli investitori che non dispongono dell’importo minimo richiesto possono entrare a far parte di pool di staking in cui partecipano congiuntamente al processo di convalida della transazione. <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> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sono esempi di blockchain che <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">utilizzare il meccanismo di consenso proof-of-stake</a>.</p>
<h2 id="h2-Ethereum2020prova20del20palo168243"><a name="Ethereum  prova del palo" 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> prova del palo</h2><p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Blockchain è una delle reti che utilizza il meccanismo di consenso del proof of stake. Affinché qualcuno diventi un validatore, deve scommettere almeno 32 ETH. Il validatore dovrebbe inoltre avere tre programmi software che supportano il processo di convalida. Questi sono un validatore, un client di consenso e un client di esecuzione.</p>
<p>A proposito, da molto tempo <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La blockchain utilizzava il meccanismo di consenso proof-of-work fino a quando è passata a quello di proof-of-stake nel settembre 2022. Il motivo principale di tale aggiornamento era ridurre il consumo energetico della blockchain e migliorare la scalabilità. È importante notare che le funzioni dei meccanismi di consenso sono approvare transazioni accurate che avvengono all’interno delle reti. Tuttavia, differiscono per il modo in cui avviene il processo di convalida.<br><img src="https://gimg2.gateimg.com/image/article/1673855593333.png" alt=""></p>
<h2 id="h2-Differenza20tra20proof20of20work20e20proof20of20stake692245"><a name="Differenza tra proof of work e proof of stake" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Differenza tra proof of work e proof of stake</h2><p><img src="https://gimg2.gateimg.com/image/article/1673855629444.png" alt=""></p>
<p>Proof of work vs proof of stake - Deltaexchange</p>
<p>Ora che abbiamo discusso del meccanismo di consenso della prova di lavoro e della prova di scommessa, confrontiamo i due.<br><img src="https://gimg2.gateimg.com/image/article/1673855720555.png" alt=""></p>
<h2 id="h2-Cosa2020meglio20il20meccanismo20di20consenso20proof20of20work20e20quello20proof20of20stake648226"><a name="Cosa è meglio: il meccanismo di consenso proof of work e quello proof of stake?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è meglio: il meccanismo di consenso proof of work e quello proof of stake?</h2><p>La verità è che il meccanismo di consenso del proof of work e quello del proof of stake hanno i loro pro e contro. Di conseguenza, è difficile concludere che uno sia migliore dell’altro. Tuttavia, esploriamo brevemente le tre aree chiave che differenziano i due.</p>
<h3 id="h3-Grado20di20centralizzazione749120"><a name="Grado di centralizzazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grado di centralizzazione</h3><p>In confronto, le blockchain che utilizzano <a href="https://ventures.gate.io/ru/learn/articles/what-is-pos-staking/10" target="_blank">i meccanismi di consenso proof-of-stake sembrano essere</a> più decentralizzato rispetto a quelli che dipendono da meccanismi di proof-of-work. Il meccanismo del proof of stake consente a molti utenti di partecipare alla blockchain in quanto possono scommettere qualsiasi quantità di criptovaluta che possiedono.</p>
<p>Gli utenti che non possono permettersi l’importo minimo di criptovaluta richiesto per diventare validatori possono unirsi ai gruppi di staking. Il numero di validatori per le blockchain che utilizzano il meccanismo di consenso proof of work è relativamente piccolo perché devono acquistare costosi attrezzature di mining come ASIC. Oltre a ciò, devono sostenere altre spese come il costo dell’elettricità.</p>
<h3 id="h3-Sicurezza20di20rete311548"><a name="Sicurezza di rete" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sicurezza di rete</h3><p>La possibilità di un attacco del 51% su blockchain che utilizzano il meccanismo di consenso proof of stake è inferiore rispetto a quelle reti che si basano sul proof of work. Questo perché non vi è alcun beneficio economico nell’effettuare l’attacco poiché la blockchain può bruciare i loro token.</p>
<p>Inoltre, poiché ci sono molti investitori con token bloccati, è improbabile che un singolo individuo o un piccolo gruppo di investitori possa accumulare la quantità necessaria per effettuare l’attacco.</p>
<p>In linea di principio, con il meccanismo di consenso del proof of work è molto difficile per alcuni minatori controllare più del 50% della potenza di calcolo di una blockchain. Tuttavia, gli attaccanti possono ottenere più del 50% della potenza di calcolo delle blockchain che hanno una piccola capitalizzazione di mercato.</p>
<h3 id="h3-Consumo20di20energia827436"><a name="Consumo di energia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Consumo di energia</h3><p>Il mining di criptovalute consuma molta energia, il che lo rende molto costoso. Tecnicamente, la potenza di calcolo necessaria per risolvere il puzzle crittografico consuma molta elettricità. Per questo motivo, gli ambientalisti hanno condotto una campagna contro il mining di criptovalute.<br><img src="https://gimg2.gateimg.com/image/article/1673855807666.png" alt=""></p>
<p>Proof of work consumo energetico- Thenextweb</p>
<p>Tuttavia, le blockchain che utilizzano il meccanismo di consenso del proof of stake non consumano molta energia. L’esempio <a href="https://www.gate.io/bitwiki/detail/102/ethereum" target="_blank">della blockchain Ethereum</a> posso rendere questo chiaro. Quando il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> quando la blockchain è passata dal meccanismo del proof of work a quello del proof of stake, il suo consumo di elettricità è diminuito del 99,9%.</p>
<p>Il confronto sopra sembra indicare che il meccanismo di consenso del proof-of-stake è migliore di quello del proof-of-work. Tuttavia, è necessario più tempo per giungere a una tale conclusione con fiducia poiché il meccanismo di consenso del proof-of-stake è stato testato solo per un breve periodo e su una scala più ridotta rispetto a quello del proof-of-work.</p>
<h3 id="h3-Conclusione844140"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>Ci sono diversi meccanismi di consenso blockchain in funzione. Tuttavia, i meccanismi di proof-of-work e proof-of-stake sono i più popolari. È importante notare che il meccanismo di proof-of-work utilizza il mining di criptovalute come mezzo per verificare le transazioni, mentre quello di proof-of-stake si affida ai validatori che scommettono una certa quantità di criptovalute.</p>
<h2 id="h2-Domande20frequenti20sulle20differenze20tra20PoW20e20PoS828621"><a name="Domande frequenti sulle differenze tra PoW e PoS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle differenze tra PoW e PoS</h2><h3 id="h3-Perch2020necessario20il20proof20of20work202020Bitcoin20927038"><a name="Perché è necessario il proof of work?   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché è necessario il proof of work? <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Proof of work è un meccanismo di consenso in cui i validatori risolvono complessi problemi matematici come mezzo per verificare le transazioni e aggiungerle alla blockchain. È un metodo provato e robusto per garantire la sicurezza di una rete blockchain come quella di Gate.io. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La rete. Impedisce possibili attacchi da parte di attori maligni come hacker e previene la doppia spesa di BTC.</p>
<h3 id="h3-In20cosa20differisce20la20prova20del20lavoro20dalla20prova20dellinteresse752312"><a name="In cosa differisce la prova del lavoro dalla prova dell’interesse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In cosa differisce la prova del lavoro dalla prova dell’interesse?</h3><p>La differenza principale è che la prova di lavoro si basa sulla risoluzione di equazioni crittografiche per convalidare le transazioni e aggiungerle a una blockchain. In entrambi i casi, un nodo che ha la maggiore potenza di calcolo è in grado di approvare la transazione. Tuttavia, con il meccanismo della prova di partecipazione, i validatori devono bloccare una grande quantità della criptovaluta nativa per verificare le transazioni su una blockchain. Inoltre, il validatore che detiene la maggiore quantità di token bloccati è molto probabilmente quello che approverà la transazione e la aggiungerà alla rete.</p>
<h3 id="h3-Perch20PoS2020migliore20di20PoW326964"><a name="Perché PoS è migliore di PoW?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché PoS è migliore di PoW?</h3><p>In primo luogo, la prova del lavoro e la prova della partecipazione sono simili in quanto sono meccanismi di consenso utilizzati per verificare e aggiungere transazioni alle blockchain. Con PoW i partecipanti alla rete utilizzano molta potenza di calcolo, che consuma molta energia, per verificare le transazioni. Tuttavia, PoS richiede ai partecipanti alla rete di bloccare una certa quantità di criptovaluta nativa sulla rete per verificare e aggiungere le transazioni alla blockchain. Pertanto, PoS non consuma tanta energia quanto PoW. Inoltre, PoS è più scalabile, veloce e conveniente di PoW.</p>
<h3 id="h3-Fare202020Alessio2020usare20la20prova20del20lavoro20o20la20prova20della20partecipazione295163"><a name="Fare   Alessio  usare la prova del lavoro o la prova della partecipazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> usare la prova del lavoro o la prova della partecipazione?</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> utilizza un meccanismo di consenso basato sulla prova del lavoro in cui i partecipanti alla rete risolvono complesse equazioni matematiche per approvare le transazioni e aggiungerle alla rete. Questo processo di utilizzo della potenza di calcolo per risolvere le equazioni crittografiche e produrre nuove monete è chiamato mining. In cambio, la blockchain premia il primo nodo che risolve l’equazione con 6,25 BTC.</p>
<h3 id="h3-Qual2020la20differenza20tra20proof20of20work20e20proofofauthority722788"><a name="Qual è la differenza tra proof of work e proof-of-authority?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la differenza tra proof of work e proof-of-authority?</h3><p>Il meccanismo di consenso della prova di autorità assegna il ruolo di validatori a un piccolo numero di partecipanti alla rete. Tuttavia, con il meccanismo di prova di lavoro, i validatori utilizzano la loro potenza di calcolo per risolvere complessi problemi matematici come mezzo per convalidare le transazioni. Poiché i validatori che utilizzano il meccanismo di prova di lavoro competono per risolvere l’equazione complessa, la blockchain premia solo quello che verifica la transazione.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga menzionato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>