Q3J5cHRvIHZlcmJyYW5kaW5nIGVuIHdhYXJvbSBCaXRjb2luIGVyIGdlZW4gbm9kaWcgaGVlZnQ=

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong></p>
<p>🔹 Cryptocurrency verbranden houdt in dat tokens en munten uit omloop worden gehaald.</p>
<p>🔹 Veel blockchains verbranden cryptocurrency om hun circulerende voorraad te verminderen, waardoor hun waarde stijgt.</p>
<p>🔹 Proof-of-burn is een blockchain-consensusmechanisme dat afhankelijk is van het verbranden van cryptocurrency om het netwerk te beveiligen en transacties te valideren.</p>
<p>🔹 <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">Tegenpartij</a>, een protocol dat bestaat op de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blockchain, verbrandde 2.124 BTC om zijn token, XCP, te slaan.</p>
<h2 id="h2-Introductie939155"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Cryptocurrencies werken correct op basis van strenge regels die worden gehandhaafd door slimme contracten. Elk blockchain heeft echter een unieke reeks regels die verklaart waarom sommige netwerken tokens verbranden terwijl anderen dat niet doen. Ook kan het proces van het verbranden van cryptocurrency verschillen van de ene blockchain tot de andere. In dit artikel verkennen we wat het verbranden van cryptocurrency betekent en de redenen voor het ‘vernietigen’ van de tokens en munten op die manier.</p>
<h2 id="h2-Wat20is20cryptocurrency20verbranding645235"><a name="Wat is cryptocurrency verbranding?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is cryptocurrency verbranding?</h2><p>Cryptocurrency burning is het proces van het permanent verwijderen van tokens of munten uit de circulerende voorraad. Dit is anders dan het verliezen van cryptocurrency door ze per ongeluk naar een verkeerd portefeuille-adres te sturen waar je ze nooit meer terug kunt krijgen.</p>
<p>In de meeste glen zijn de ontwikkelingsteams verantwoordelijk voor het verbranden van crypto, met als doel een bepaald doel te bereiken zoals het beveiligen van het netwerk. Bijvoorbeeld, het team kan de tokens terugkopen en verbranden. Als alternatief kunnen ze de cryptocurrency verbranden die ze voor dat doel hebben vastgehouden.</p>
<h2 id="h2-Hoe20werkt20het20verbranden20van20cryptocurrency206189"><a name="Hoe werkt het verbranden van cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt het verbranden van cryptocurrency?</h2><p>Er zijn verschillende methoden die blockchains kunnen gebruiken om cryptocurrency te verbranden, afhankelijk van hun architectuur. De meest voorkomende manier is om de tokens naar een speciaal portemonnee-adres te sturen dat geen privésleutel heeft. Hierdoor zal er nooit een manier zijn om er toegang toe te krijgen, wat betekent dat ze voor altijd ‘vernietigd’ zijn.</p>
<p>Wat dit ook betekent is dat een gebruiker die van plan is zijn/haar tokens te verbranden, ze naar een ongeldig portemonnee-adres kan sturen. Technisch gezien laat dit zien dat mensen cryptocurrencies kunnen verbranden zoals <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a>, die geen verbrandingsmechanisme hebben, door ze naar ongeldige walletadressen te sturen.</p>
<p>Er zijn ook blockchains zoals Binance die vernietigingsmechanismen hebben voor het vernietigen van hun eigen tokens. Daarom is het mogelijk voor elke Binance Coin-houder om deze te vernietigen. De munt-houder kan aangeven hoeveel hij/zij wil vernietigen en de nodige opdracht geven. Als zodanig verwijdert de blockchain eenvoudigweg het aangegeven bedrag van het saldo van de houder, wat resulteert in de vermindering van de omloop.</p>
<p>In andere situaties verloopt het verbrandingsproces automatisch bij het voldoen aan bepaalde voorwaarden. Als voorbeeld verbranden bepaalde blockchains, zoals Ethereum, een bepaald percentage van de transactiekosten. Op een gegeven moment richtte <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> een verbrandingsportaal op waar alle bereidwillige tokenhouders hun SHIB konden verbranden.</p>
<h2 id="h2-Redenen20voor20het20verbranden20van20cryptocurrencies224520"><a name="Redenen voor het verbranden van cryptocurrencies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen voor het verbranden van cryptocurrencies</h2><p>Zoals eerder vermeld, hebben verschillende blockchains verschillende redenen om cryptos te verbranden, waaronder het verhogen van de waarde van de cryptocurrency, het bevorderen van de mijnbouwbalans en het stabiliseren van de waarde van stablecoins.</p>
<h3 id="h3-Proofofburn20PoB672586"><a name="Proof-of-burn (PoB)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Proof-of-burn (PoB)</h3><p>Proof-of-burn is een ander blockchain-consensusmechanisme, hoewel het niet zo populair is als de proof-of-work of proof-of-stake mechanismen. De gebruikers van bepaalde blockchains, die toegewijd zijn aan het netwerk, kunnen hun tokens verbranden om het recht te krijgen om transacties te valideren of de native cryptocurrency te delven.</p>
<p>In dit g vertegenwoordigt het proces van het verbranden van cryptocurrencies virtuele mijnkracht. Een gebruiker die meer tokens verbrandt dan de anderen, heeft een grotere kans om geselecteerd te worden als transactiidator. De beloning die de validators krijgen, dekt de investering van de tokens die ze verbranden. Tegelijkertijd beveiligt het verbranden van de cryptocurrency het netwerk tegen aanvallen.</p>
<h3 id="h3-Bescherming20tegen20spam402442"><a name="Bescherming tegen spam" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bescherming tegen spam</h3><p>Het verbranden van cryptocurrencies betekent veel meer dan alleen een consensusmechanisme zijn. Het beschermt het netwerk tegen Distributed Denial of Service (DDoS) aanvallen waarbij spamverzoeken het netwerk vertragen. Daarom vermindert dit proces de mogelijkheid van spam die het netwerk overspoelt.</p>
<h3 id="h3-Opzettelijke20verbrandingen20om20de20waarde20te20verhogen346292"><a name="Opzettelijke verbrandingen om de waarde te verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opzettelijke verbrandingen om de waarde te verhogen</h3><p>De andere belangrijke reden waarom sommige blockchains hun eigen cryptocurrencies verbranden is om hun waarde te verhogen. Dit komt doordat het verbranden van cryptocurrency de omloopvoorraad vermindert.<br>Volgens de wet van vraag en aanbod zal een afname van het aanbod van een token, vergezeld door een constante of stijgende vraag, waarschijnlijk de waarde ervan verhogen. Dit is vergelijkbaar met de praktijk van het terugkopen van aandelen om het aantal uitstaande aandelen te verminderen. Om de prijs van de cryptocurrency te laten stijgen, moet de blockchain een grote hoeveelheid van de token verbranden.</p>
<p>Het is vermeldenswaard dat het lang kan duren voordat de prijs stijgt. Helaas en in de ergste glen kan de prijs zelfs niet stijgen omdat andere factoren een rol kunnen spelen.</p>
<h3 id="h3-Het20stabiliseren20van20de20waarde20van20stablecoins186732"><a name="Het stabiliseren van de waarde van stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het stabiliseren van de waarde van stablecoins</h3><p>Stablecoins spelen een grote rol in het cryptosysteem omdat mensen ze als ruilmiddel gebruiken. De reden waarom veel bedrijven en individuen <a href="https://www.gate.io/price/view/stablecoins" target="_blank">accepteer stablecoins</a> in ruil voor goederen en diensten is dat hun prijzen over een lange periode constant blijven.</p>
<p>Aangezien de koppeling van algoritmische stablecoins afhangt van het handhaven van een evenwicht tussen vraag en aanbod, speelt verbranding een cruciale rol. Algoritmische stablecoins passen hun voorraden automatisch aan om aan de marktvraag te voldoen.<br><img src="https://gimg2.gateimg.com/image/article/1674027555111.png" alt=""></p>
<p>Stabiliteit van algoritmische stablecoins hangt af van brandende tokens - Zeeve</p>
<p>Bijvoorbeeld, als de prijs van de stablecoin daalt, brandt de blockchain enkele van de tokens om de bestaande prijspariteit te handhaven. Daarentegen, als de prijs stijgt, maakt de blockchain meer tokens aan om aan de vraag te voldoen, waardoor de dollar-gekoppelde waarde wordt gehandhaafd.</p>
<h3 id="h3-Als20teken20van20langdurige20betrokkenheid539819"><a name="Als teken van langdurige betrokkenheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Als teken van langdurige betrokkenheid</h3><p>Sommige ontwikkelingsteams nemen periodieke cryptoverbrandingsmechanismen op als onderdeel van hun slimme contracten om de schaarste van de cryptocurrencies te handhaven. Op deze manier creëren ze periodieke verbrandingsschema’s die kunnen helpen om opwaartse prijsmomentum te creëren voor hun cryptocurrencies of op zijn minst een bepaald waardebereik te handhaven.</p>
<p>Deze strategie helpt het vertrouwen van hun gebruikers te behouden en nieuwe investeerders aan te trekken. Bovendien tonen deze muntverbrandingen het langetermijnengagement van het team voor de toekomst van hun projecten.</p>
<h3 id="h3-Bevordering20van20de20mijnbouwbalans821934"><a name="Bevordering van de mijnbouwbalans" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bevordering van de mijnbouwbalans</h3><p>Constant brandende crypto helpt de blockchain om de investeringsbalans tussen oude en nieuwe gebruikers te handhaven. Dit gebeurt wanneer de blockchain het slaan van nieuwe munten toestaat na crypto-verbrandingsevenementen. Met blockchains die gebruikmaken van PoB-consensusmechanismen, hebben gebruikers de kans om nieuwe tokens of munten te delven na elk verbrandingsevenement.</p>
<h2 id="h2-De20geschiedenis20van20het20verbranden20van20cryptocurrency850692"><a name="De geschiedenis van het verbranden van cryptocurrency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De geschiedenis van het verbranden van cryptocurrency</h2><p>Cryptocurrency-verbranding begon in 2017 en breidde zich uit in 2018 naarmate meer blockchains verbrandingsmechanismen aannamen. De ontwikkelingsteams achter Binance Coin (BNB), <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Cash (BCH) en <a href="/price/stellar-xlm" target="_blank" class="blog_inner_link">Stellar</a> (XLM) waren de eersten die burn-mechanismen gebruikten om de waarden van hun cryptocurrencies te verhogen.</p>
<p>Als voorbeeld voerde Binance veel burn-evenementen uit om de omloopvoorraad van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> met 100 miljoen te verminderen. Ook had de Stellar blockchain tegen 2019 55 miljard XLM verbrand, ongeveer de helft van zijn totale voorraad. Een ander opmerkelijk voorbeeld is dat van Shiba Inu, de memecoin. In 2021 schonk het de helft van zijn voorraad aan Ethereum-medeoprichter, Vitalik Buterin. Buterin heeft echter 90% van de gedoneerde SHIB-tokens verbrand en de rest gedoneerd.<br><img src="https://gimg2.gateimg.com/image/article/1674028180222.png" alt=""></p>
<p>Shiba Inu heeft bijna de helft van zijn totale aanbod verbrand - Thecryptobasic</p>
<p>Vanaf die periode en af en toe hebben veel blockchains delen van hun cryptobezittingen verbrand om hun waarde op de markt te beïnvloeden. Bijvoorbeeld; recentelijk heeft de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain het verbranden van een deel van haar transactiekosten geïntroduceerd als een middel om de omloop van ETH te verminderen.</p>
<h2 id="h2-De20reden20waarom202020Bitcoin2020hoeft20niet20te20worden20verbrand37137"><a name="De reden waarom   Bitcoin  hoeft niet te worden verbrand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De reden waarom <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> hoeft niet te worden verbrand</h2><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is een van de blockchains die geen mechanisme voor het verbranden van munten heeft. Er zijn echter veel BTC die in de loop der jaren per ongeluk zijn verbrand. Een project met de naam <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> verbrand 2.124 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> als onderdeel van proof-of-burn om zijn eigen token genaamd XCP te produceren. Trouwens, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">Tegenpartij</a> is een open source project gebouwd op de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blockchain.</p>
<p>De waarschijnlijke reden waarom het niet nodig is voor de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Een van de redenen waarom blockchain BTC verbrandt, is het relatief kleine totale aanbod van 21 miljoen. Ten tweede vermindert het de hoeveelheid BTC die mensen delven door zijn halveringsevenementen die plaatsvinden nadat er 210.000 blokken aan de blockchain zijn toegevoegd.</p>
<h2 id="h2-Kun20je20branden202020Bitcoin20206152"><a name="Kun je branden?   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kun je branden? <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h2><p>Hoewel <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> heeft geen verbrandingsmechanisme, iedereen kan het verbranden door het naar een ongeldig portefeuilleadres te sturen. Bijvoorbeeld, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> stuurde zijn BTC naar het portefeuilleadres, 1CounterpartyXXXXXXXXXXXXXXXUWLpVr, dat fungeerde als zijn brandadres.</p>
<h3 id="h3-Conclusie831519"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Het verbranden van cryptocurrency is het proces waarbij sommige tokens of munten permanent uit de circulatie worden gehaald door ze naar een portemonnee te sturen die geen privésleutel heeft. Blockchains kunnen hun tokens om verschillende redenen verbranden, waaronder het verhogen van de waarde van hun cryptocurrencies, het bevorderen van de miningbalans en het stabiliseren van de waarde van stablecoins.</p>
<h2 id="h2-Veelgestelde20vragen20over20het20verbranden20van20cryptocurrency647122"><a name="Veelgestelde vragen over het verbranden van cryptocurrency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over het verbranden van cryptocurrency</h2><h3 id="h3-Wat20is20bewijs20van20verbranding20in202020Bitcoin20930651"><a name="Wat is bewijs van verbranding in   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is bewijs van verbranding in <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Proof of burn is een consensusmechanisme waarbij mijnwerkers of validators de tokens verbranden die ze hebben om de macht te krijgen om blokken aan de blockchain toe te voegen. Hoewel <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> heeft geen mechanisme om zijn munten te verbranden, sommige projecten die gebouwd zijn op de blockchain kunnen dit echter wel doen. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> om hun eigen cryptocurrency te genereren. Bijvoorbeeld, <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a>, een cryptoproject gebaseerd op de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Netwerk heeft 2.124 BTC verbrand als onderdeel van een procedure om zijn eigen inheemse token XCP te creëren. <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">CounterParty</a> overgedragen de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> naar een portefeuilleadres zonder privésleutel.</p>
<h3 id="h3-Does202020Bitcoin2020tokens20verbranden822923"><a name="Does   Bitcoin  tokens verbranden" 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> tokens verbranden</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> heeft geen token-verbrandingsmechanisme. Individuen kunnen echter BTC verbranden door het naar een ongeldig portefeuilleadres te sturen. In zekere zin zijn de mensen die hun <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> door foutieve adressen te sturen hebben ze deze verbrand omdat ze deze nooit meer kunnen herstellen. Bijvoorbeeld, James Howells, een Britse burger, beweert dat hij zijn harde schijf met 7.500 BTC heeft weggegooid.</p>
<p>Technisch gezien heeft hij daarmee de 7.500 BTC verbrand omdat niemand ze kan herstellen.</p>
<h2 id="h2-Hoeveel202020Bitcoin2020worden20verbrand656632"><a name="Hoeveel   Bitcoin  worden verbrand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> worden verbrand</h2><p>Het geregistreerde aantal Bitcoins dat is verbrand, is 2.124. <a href="https://www.gate.io/trade/XCP_USDT" target="_blank">Tegenpartij</a> verzonden naar het portefeuilleadres 1CounterpartyXXXXXXXXXXXXXXXUWLpVr. Als we het woord ‘verbranden’ echter opvatten als permanent uit de omloop verwijderen, zouden er meer dan 1 miljoen verbrande BTC kunnen zijn. Zo beweert bijvoorbeeld de Britse staatsburger James Howells dat hij een harde schijf heeft weggegooid die 7.500 BTC bevatte, en wordt aangenomen dat Satoshi Nakamoto tussen de 750.000 en 1 miljoen BTC heeft gedolven en naar verschillende portefeuilles heeft gestuurd.</p>
<p>Experts geloven echter dat deze hoeveelheid <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is nog nooit gebruikt.</p>
<h3 id="h3-Verhoogt20het20verbranden20van20cryptovaluta20de20waarde184578"><a name="Verhoogt het verbranden van cryptovaluta de waarde?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verhoogt het verbranden van cryptovaluta de waarde?</h3><p>Technisch gezien vermindert het verbranden van cryptocurrency de omloop ervan, wat zou moeten helpen om de waarde te verhogen als de vraag constant blijft of toeneemt. De prijs van de cryptocurrency kan echter alleen stijgen als de blockchain een grote hoeveelheid van de token of munt verbrandt. Bovendien kan verbranding leiden tot een stijging van de waarde van een cryptocurrency als er een grote koopkracht op de markt is.</p>
<h3 id="h3-Wat20gebeurt20er20na20het20verbranden20van20munten400957"><a name="Wat gebeurt er na het verbranden van munten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat gebeurt er na het verbranden van munten?</h3><p>Het verbranden van munten betekent dat de cryptocurrency permanent uit omloop is gehaald. Als gevolg hiervan zal niemand ze daarna kunnen herstellen en gebruiken. Dit is de reden waarom cryptogebruikers hun bestemmingadressen moeten controleren en verifiëren voordat ze hun cryptocurrencies verzenden.</p>
<h3 id="h3-Is20het20mogelijk20om20te20verbranden202020Bitcoin20512845"><a name="Is het mogelijk om te verbranden   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het mogelijk om te verbranden <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>Ja, het is mogelijk om te verbranden <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> door het te verzenden naar een wallet adres dat geen privésleutel heeft. Als alternatief kan iemand die het wil vernietigen <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> kan het naar een ongeldig adres sturen. Er is echter geen vastgestelde <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> verbrandingsadres dat instellingen en particulieren kunnen gebruiken.</p>
<h3 id="h3-Welke20cryptovaluta20zal20munten20verbranden116691"><a name="Welke cryptovaluta zal munten verbranden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke cryptovaluta zal munten verbranden?</h3><p>Er zijn veel blockchains die hun munten en tokens kunnen verbranden. Deze omvatten onder andere de Ethereum, Binance Chain, Stellar, Shiba Inu en Filecoin. Binance (BNB) heeft bijvoorbeeld een autoburn-programma, terwijl Ethereum een vast deel van de transactiekosten verbrandt.</p>
<h3 id="h3-Is20het20verbranden20van20cryptocurrency20goed20of20slecht4680"><a name="Is het verbranden van cryptocurrency goed of slecht?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het verbranden van cryptocurrency goed of slecht?</h3><p>Over het algemeen is het verbranden van cryptocurrency goed, omdat het helpt om de waarde van de token of munt te verhogen. In het g van algoritmische stablecoins stabiliseert verbranding hun waarden. Voor blockchains die het proof-of-burn consensusmechanisme gebruiken, is verbranding belangrijk voor het beveiligen van het netwerk en het valideren van transacties.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits naar Gate.io wordt verwezen. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>