TGEgYnJ1Y2lhdHVyYSBkaSBjcnlwdG8gZSBwZXJjaMOpIEJpdGNvaW4gbm9uIG5lIGhhIGJpc29nbm8=

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong></p>
<p>🔹 La bruciatura di criptovaluta comporta la rimozione di token e monete dalla circolazione.</p>
<p>🔹 Molte blockchain bruciano criptovalute per ridurre la loro offerta circolante, aumentando così il loro valore.</p>
<p>🔹 Il proof-of-burn è un meccanismo di consenso blockchain che dipende dalla bruciatura di criptovalute per garantire la sicurezza della rete e convalidare le transazioni.</p>
<p>🔹 <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a>, un protocollo esistente sul <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> Blockchain, ha bruciato 2.124 BTC per coniare il suo token, XCP.</p>
<h2 id="h2-Introduzione590282"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le criptovalute funzionano correttamente in base a regole rigorose applicate dagli smart contract. Tuttavia, ogni blockchain ha un insieme unico di regole che spiega perché alcune reti bruciano token mentre altre no. Inoltre, il processo di masterizzazione della criptovaluta può differire da una blockchain all’altra. In questo articolo, esploriamo cosa significa bruciare la criptovaluta e le ragioni per “distruggere” i token e le monete in questo modo.</p>
<h2 id="h2-Cos20il20burning20delle20criptovalute986403"><a name="Cos’è il burning delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il burning delle criptovalute?</h2><p>Il burning di criptovalute è un processo di rimozione permanente di token o monete dall’offerta circolante. Questo è diverso dalla perdita di criptovaluta inviandola per errore a un indirizzo di portafoglio errato dove non puoi mai recuperarla.</p>
<p>Nella maggior parte dei casi, i team di sviluppo sono responsabili della masterizzazione delle criptovalute, con l’obiettivo di raggiungere un determinato obiettivo come la sicurezza della rete. Ad esempio, il team può riacquistare i token e bruciarli. In alternativa, possono bruciare la criptovaluta che hanno detenuto a tale scopo.</p>
<h2 id="h2-Come20funziona20la20bruciatura20di20criptovaluta326799"><a name="Come funziona la bruciatura di criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona la bruciatura di criptovaluta?</h2><p>Ci sono diversi metodi che le blockchain possono utilizzare per bruciare la criptovaluta, a seconda della loro architettura. Il modo più comune è quello di inviare i token a un indirizzo del portafoglio speciale che non ha una chiave privata. In questo modo non ci sarà mai un modo per accedervi, il che significa che sono “distrutti” per sempre.</p>
<p>Ciò significa anche che un utente che intende bruciare i suoi token può inviarli a un indirizzo di portafoglio non valido. Tecnicamente, ciò dimostra che le persone possono bruciare criptovalute come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, che non hanno meccanismo di bruciatura, inviandoli a indirizzi wallet non validi.</p>
<p>Ci sono anche blockchains come Binance che hanno meccanismi di bruciatura per distruggere i loro token nativi. Pertanto, è possibile che ogni detentore di Binance Coin lo bruci. Il detentore del token può indicare l’importo che desidera bruciare e dare il comando necessario. In questo modo, la blockchain rimuove semplicemente l’importo indicato dal saldo del detentore, con conseguente riduzione dell’offerta circolante.</p>
<p>In altre situazioni, il processo di combustione è automatico al verificarsi di determinate condizioni. Ad esempio, alcune blockchain, come Ethereum, bruciano una certa proporzione della commissione di transazione. In un certo periodo, <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> ha istituito un portale di combustione in cui tutti i titolari di token volontari potevano bruciare i loro SHIB.</p>
<h2 id="h2-Motivi20per20bruciare20criptovalute645431"><a name="Motivi per bruciare criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per bruciare criptovalute</h2><p>Come precedentemente indicato, diverse blockchain hanno varie ragioni per bruciare criptovalute che includono l’aumento del valore della criptovaluta, la promozione dell’equilibrio minerario e la stabilizzazione del valore delle stablecoin.</p>
<h3 id="h3-Proofofburn20PoB411901"><a name="Proof-of-burn (PoB)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Proof-of-burn (PoB)</h3><p>La proof-of-burn è un altro meccanismo di consenso della blockchain, anche se non è così popolare come quella proof-of-work o proof-of-stake. Gli utenti di alcune blockchain, che sono impegnati nella rete, possono bruciare i loro token per ottenere il diritto di convalidare le transazioni o estrarre la criptovaluta nativa.</p>
<p>In questo caso, il processo di combustione delle criptovalute rappresenta una potenza di mining virtuale. Un utente che brucia più token degli altri ha maggiori possibilità di essere selezionato come validatore di transazioni. La ricompensa che i validatori ottengono copre l’investimento dei token che bruciano. Allo stesso tempo, il burning della criptovaluta protegge la rete dagli attacchi.</p>
<h3 id="h3-Protezione20contro20lo20spam170327"><a name="Protezione contro lo spam" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Protezione contro lo spam</h3><p>Bruciare le criptovalute significa molto di più che essere un meccanismo di consenso. Protegge la rete dagli attacchi di negazione del servizio distribuito (DDoS), in cui le richieste di spam rallentano la rete. Pertanto, questo processo riduce la possibilità di allagamenti di spam nella rete.</p>
<h3 id="h3-Bruciature20intenzionali20per20aumentare20il20valore958935"><a name="Bruciature intenzionali per aumentare il valore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bruciature intenzionali per aumentare il valore</h3><p>L’altro motivo principale per cui alcune blockchain bruciano le loro criptovalute native è aumentare il loro valore. Ciò perché bruciare una criptovaluta riduce la sua offerta circolante.<br>Secondo la legge della domanda e dell’offerta, una diminuzione dell’offerta di un token, accompagnata da una domanda costante o in aumento, è probabile che aumenti il suo valore. Questo è simile alla pratica di riacquistare azioni per ridurre la quantità di azioni in circolazione. Per far aumentare il prezzo della criptovaluta, la blockchain dovrebbe bruciare una grande quantità del token.</p>
<p>Vale la pena notare che potrebbe passare molto tempo prima che il prezzo aumenti. Purtroppo, nei casi peggiori, il prezzo potrebbe non aumentare nemmeno poiché potrebbero entrare in gioco altri fattori.</p>
<h3 id="h3-Stabilizzare20il20valore20delle20stablecoin227058"><a name="Stabilizzare il valore delle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stabilizzare il valore delle stablecoin</h3><p>Le stablecoin stanno svolgendo un grande ruolo nell’ecosistema delle criptovalute poiché le persone li utilizzano come mezzo di scambio. Il motivo per cui molte aziende e individui <a href="https://www.gate.io/price/view/stablecoins" target="_blank">accettare stablecoin</a> in cambio di beni e servizi è che i loro prezzi sono costanti nel tempo.</p>
<p>Poiché il peg delle stablecoin algoritmiche dipende dal mantenimento di un equilibrio tra offerta e domanda, il burning svolge un ruolo critico. Le stablecoin algoritmiche regolano automaticamente le proprie forniture per soddisfare la domanda di mercato.<br><img src="https://gimg2.gateimg.com/image/article/1674027555111.png" alt=""></p>
<p>La stabilità delle stablecoin algoritmiche dipende dalla riduzione dei token - Zeeve</p>
<p>Ad esempio, se il prezzo della stablecoin diminuisce, la blockchain brucia alcuni dei token per mantenere la parità di prezzo esistente. Al contrario, se il prezzo aumenta, la blockchain conia più token per soddisfare la domanda, mantenendo così il valore ancorato al dollaro.</p>
<h3 id="h3-Come20segno20di20impegno20a20lungo20termine231495"><a name="Come segno di impegno a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come segno di impegno a lungo termine</h3><p>Alcuni team di sviluppo incorporano meccanismi di burn periodico delle criptovalute come parte dei loro contratti intelligenti per mantenere la scarsità delle criptovalute. In questo modo, creano programmi di burn periodici che possono aiutare a creare uno slancio al rialzo del prezzo per le loro criptovalute o almeno a mantenere un certo intervallo di valore.</p>
<p>Questa strategia aiuta a mantenere la fiducia dei loro utenti e ad attirare nuovi investitori. Inoltre, queste bruciature di monete mostrano l’impegno a lungo termine del team per il futuro dei loro progetti.</p>
<h3 id="h3-Promuovere20il20saldo20del20mining44017"><a name="Promuovere il saldo del mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Promuovere il saldo del mining</h3><p>Il costante burning di criptovalute aiuta la blockchain a mantenere l’equilibrio degli investimenti tra vecchi utenti e nuovi. Ciò si verifica quando la blockchain consente il conio di nuove monete a seguito di eventi di burn delle criptovalute. Con le blockchain che utilizzano i meccanismi di consenso PoB, gli utenti hanno la possibilità di estrarre nuovi token o monete dopo ogni evento di burn.</p>
<h2 id="h2-La20storia20del20bruciare20criptovalute217530"><a name="La storia del bruciare criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La storia del bruciare criptovalute</h2><p>La bruciatura della criptovaluta è iniziata nel 2017 ed è stata ampliata nel 2018 con l’adozione di meccanismi di bruciatura da parte di un numero crescente di blockchain. I team di sviluppo dietro Binance Coin (BNB), <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> Cash (BCH) e <a href="/price/stellar-xlm" target="_blank" class="blog_inner_link">Stellar</a> (XLM) sono stati i primi a utilizzare meccanismi di burn per aumentare il valore delle loro criptovalute.</p>
<p>Come esempio, Binance ha effettuato molti eventi di bruciatura per ridurre l’offerta circolante di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> di 100 milioni. Inoltre, entro il 2019 la blockchain di Stellar aveva bruciato 55 miliardi di XLM, circa la metà della sua offerta totale. Un altro esempio significativo è quello di Shiba Inu, la memecoin. Nel 2021 ha donato metà della sua offerta al co-fondatore di Ethereum, Vitalik Buterin. Tuttavia, Buterin ha bruciato il 90% dei token SHIB donati e ha donato il resto.<br><img src="https://gimg2.gateimg.com/image/article/1674028180222.png" alt=""></p>
<p>Shiba Inu ha bruciato quasi la metà della sua offerta totale - Thecryptobasic</p>
<p>Da quel periodo in poi e di tanto in tanto, molte blockchains hanno bruciato frazioni delle loro cripto detenzioni per influenzare il loro valore sul mercato. Ad esempio, recentemente la blockchain di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha introdotto la bruciatura di una proporzione delle commissioni di transazione come mezzo per ridurre l’offerta circolante di ETH.</p>
<h2 id="h2-Il20motivo20per20cui202020Bitcoin2020non20ha20bisogno20di20bruciare391915"><a name="Il motivo per cui   Bitcoin  non ha bisogno di bruciare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il motivo per cui <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non ha bisogno di bruciare</h2><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è una delle blockchain che non ha un meccanismo di coin burning. Tuttavia, nel corso degli anni, molti BTC sono stati bruciati per errore. Un progetto chiamato <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> bruciato 2.124 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> come parte della proof-of-burn per produrre la propria token chiamata XCP. A proposito, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">Controparte</a> è un progetto open source costruito sul <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blockchain.</p>
<p>La probabile ragione per cui non è necessario per <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il motivo principale per cui il blockchain brucia BTC è la sua relativamente piccola offerta totale di 21 milioni. In secondo luogo, riduce la quantità di BTC estratti dalle persone attraverso i suoi eventi di dimezzamento che avvengono dopo l’aggiunta di 210.000 blocchi al blockchain.</p>
<h2 id="h2-Puoi20bruciare202020Bitcoin20533072"><a name="Puoi bruciare   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Puoi bruciare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h2><p>Anche se <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non ha un meccanismo di distruzione, chiunque può distruggerlo inviandolo a un indirizzo del portafoglio non valido. Per esempio, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> ha inviato il suo BTC all’indirizzo del portafoglio, 1CounterpartyXXXXXXXXXXXXXXXUWLpVr, che ha agito come il suo indirizzo di bruciatura.</p>
<h3 id="h3-Conclusion890888"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>Il bruciare la criptovaluta è il processo di rimuovere permanentemente alcuni token o monete dalla circolazione inviandoli a un portafoglio che non ha una chiave privata. Le blockchain possono bruciare i loro token per diverse ragioni, tra cui aumentare il valore delle loro criptovalute, promuovere l’equilibrio del mining e stabilizzare il valore delle stablecoin.</p>
<h2 id="h2-Domande20frequenti20sul20bruciamento20di20criptovalute939930"><a name="Domande frequenti sul bruciamento di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sul bruciamento di criptovalute</h2><h3 id="h3-Cos20la20prova20di20burn20in202020Bitcoin20877214"><a name="Cos’è la prova di burn in   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la prova di burn in <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Proof of burn è un meccanismo di consenso in cui i minatori o i validatori bruciano i token che possiedono per ottenere il potere di aggiungere blocchi alla blockchain. Anche se <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non ha un meccanismo per bruciare le sue monete, alcuni progetti costruiti sulla blockchain possono bruciare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> generare la propria criptovaluta. Ad esempio, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a>, un progetto cripto basato sul <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La rete ha bruciato 2.124 BTC come parte di una procedura per creare il proprio token nativo XCP. <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> trasferito il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> a un indirizzo del portafoglio che non ha una chiave privata.</p>
<h3 id="h3-Does202020Bitcoin2020bruciare20token584000"><a name="Does   Bitcoin  bruciare token" 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> bruciare token</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non ha un meccanismo di bruciatura dei token. Tuttavia, le persone possono bruciare BTC inviandolo a un indirizzo di portafoglio non valido. In un certo senso, le persone che inviano i loro <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> spedire per errore a indirizzi non validi li ha bruciati poiché non possono mai essere recuperati. Ad esempio, James Howells, un cittadino britannico, sostiene di aver gettato via il suo hard disk che conteneva 7.500 BTC.</p>
<p>Tecnicamente, facendo ciò ha bruciato i 7.500 BTC poiché nessuno può recuperarli.</p>
<h2 id="h2-Quanti202020Bitcoin2020vengono20bruciati398424"><a name="Quanti   Bitcoin  vengono bruciati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanti <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> vengono bruciati</h2><p>Il numero registrato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> bruciati è 2.124 che <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> inviato all’indirizzo del portafoglio 1CounterpartyXXXXXXXXXXXXXXXUWLpVr. Tuttavia, se prendiamo la parola “bruciare” nel senso di rimuoverla permanentemente dalla circolazione, potrebbero esserci più di 1 milione di BTC bruciati. Ad esempio, a parte James Howells, un cittadino britannico, che sostiene di aver gettato via un hard disk contenente 7.500 BTC, si ritiene che Satoshi Nakamoto abbia estratto tra 750.000 e 1 milione di BTC che ha inviato a vari portafogli.</p>
<p>Tuttavia, gli esperti ritengono che questa quantità di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non è mai stato usato.</p>
<h3 id="h3-Bruciare20criptovalute20aumenta20il20valore510253"><a name="Bruciare criptovalute aumenta il valore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bruciare criptovalute aumenta il valore?</h3><p>Dal punto di vista tecnico, bruciare la criptovaluta riduce la sua offerta circolante, il che dovrebbe contribuire ad aumentarne il valore se la domanda rimane costante o aumenta. Tuttavia, il prezzo della criptovaluta può aumentare solo se il blockchain brucia una grande quantità del token o della moneta. Inoltre, il bruciare può portare a un aumento del valore di una criptovaluta se c’è un alto potere d’acquisto sul mercato.</p>
<h3 id="h3-Cosa20succede20dopo20la20distruzione20delle20monete365822"><a name="Cosa succede dopo la distruzione delle monete?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succede dopo la distruzione delle monete?</h3><p>Bruciare le monete significa che la criptovaluta è stata permanentemente rimossa dalla circolazione. Di conseguenza, nessuno sarà in grado di recuperarle e usarle dopo. Questo è il motivo per cui gli utenti di cripto dovrebbero verificare i loro indirizzi di destinazione prima di inviare le loro criptovalute.</p>
<h3 id="h3-20possibile20bruciare202020Bitcoin20460831"><a name="È possibile bruciare   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È possibile bruciare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Sì, è possibile bruciare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> inviandolo a un indirizzo del portafoglio che non ha una chiave privata. In alternativa, qualcuno che vuole bruciare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> posso inviarlo a un indirizzo non valido. Tuttavia, non c’è nessuna <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> indirizzo di distruzione che istituzioni e individui possono utilizzare.</p>
<h3 id="h3-Quale20criptovaluta20brucer20le20monete842324"><a name="Quale criptovaluta brucerà le monete?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale criptovaluta brucerà le monete?</h3><p>Ci sono molte blockchain che possono bruciare le loro monete e i loro token. Questi includono Ethereum, Binance Chain, Stellar, Shiba Inu e Filecoin, tra gli altri. Ad esempio, Binance (BNB) ha un programma di autoburn mentre Ethereum brucia una frazione stabilita delle commissioni di transazione.</p>
<h3 id="h3-Bruciare20criptovalute2020bene20o20male336671"><a name="Bruciare criptovalute è bene o male?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bruciare criptovalute è bene o male?</h3><p>In generale, bruciare criptovalute è buono poiché aiuta ad aumentare il valore del token o della moneta. Nel caso delle stablecoin algoritmiche, la bruciatura stabilizza i loro valori. Per le blockchain che utilizzano il meccanismo di consenso proof-of-burn, la bruciatura è importante per garantire la sicurezza della rete e convalidare le transazioni.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>