Q3J5cHRvIDEwMTogV2F0IHppam4gdG9rZW5lbWlzc2llcyBlbiB3YWFyb20gemlqbiB6ZSBiZWxhbmdyaWprPw==

2022-12-27, 08:49

<p><img src="https://gimg2.gateimg.com/image/article/1672130848Unknown.jpeg" alt=""><br><strong>Wat zijn tokenemissies? </strong></p>
<p>Naast fundamentele zaken zoals token utility, governance en circulatie, zijn emissies een andere kerncomponent van tokenomics. Kort gezegd verwijst dit naar het tempo waarin nieuwe tokens worden gecreëerd en in omloop worden gebracht.</p>
<p>Over het algemeen worden nieuwe tokens uitgedeeld als onderdeel van blokbeloningen, die aan mijnwerkers of validators worden gegeven als beloning voor het helpen beveiligen van de blockchain. Bijvoorbeeld, wanneer <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin](https://www.gate.io/zh/trade/BTC_USDT/?ch=GM_blog_btc_20221227&amp;utm_campaign=TR_yX8kVVYm&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term= “[Bitcoin</a> Toen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> voor het eerst werd gelanceerd, ontvingen mijnwerkers elke tien minuten 50 BTC (of voor elk blok dat ze valideerden), met als gevolg een emissiesnelheid van ongeveer 7.200 BTC per dag. Vanwege een reeks ‘halveringsevenementen’ in recente jaren is deze snelheid echter aanzienlijk afgenomen. Vanaf 11 mei 2020, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin](https://www.gate.io/zh/trade/BTC_USDT/?ch=GM_blog_btc_20221227&amp;utm_campaign=TR_yX8kVVYm&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term= “[Bitcoin</a> Het protocol genereert ongeveer 6,25 BTC per blok. Hoewel de volgende halvering naar verwachting in 2024 zal plaatsvinden, zal dit emissietempo niet oneindig doorgaan. Aangezien de maximale voorraad van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is ingesteld op 21 miljoen munten en volgens het strikte emissieschema, de laatste <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> wordt naar verwachting gemijnd in 2140.</p>
<p>Emissiesnelheden zijn belangrijk omdat ze de toekomstige waarde van een token kunnen beïnvloeden. Als de snelheid bijvoorbeeld te hoog is, kan de markt overspoeld raken en kan de waarde van de token afnemen. Hoewel het uiteindelijk afhangt van het onderliggende ecosysteem en product, moet een goed ontworpen token een gestage, gecontroleerde toename van het aanbod hebben om de waarde in de loop van de tijd te behouden.</p>
<h4 id="h4-Wat20zijn20de20verschillende20types927953"><a name="Wat zijn de verschillende types?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de verschillende types?</h4><p>Er zijn verschillende soorten token-uitgiften, die kunnen variëren afhankelijk van het specifieke ontwerp van de token en de doelen van het project. Enkele veelvoorkomende types zijn:</p>
<h4 id="h4-Vaste20emissies598093"><a name="Vaste emissies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vaste emissies</h4><p>Dit verwijst naar een vaste koers die in de loop van de tijd niet verandert. De totale voorraad van de token is ook vastgesteld, en nieuwe tokens worden vrijgegeven tegen een vooraf bepaalde koers. Zoals eerder vermeld, is een voorbeeld van een token met een vaste emissie <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, die een maximale voorraad heeft van 21 miljoen munten en een vooraf bepaalde emissiesnelheid die met de tijd afneemt.</p>
<h4 id="h4-Variabele20emissies306953"><a name="Variabele emissies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Variabele emissies</h4><p>Variabele emissies verwijzen naar een tokenemissiesnelheid die in de loop van de tijd kan veranderen, meestal gebaseerd op specifieke triggers of voorwaarden. We zien dit aangetoond variabel emissietoken is de stablecoin <a href="https://www.gate.io/trade/USDT_USDT" target="_blank">Tether</a>(USDT), die nieuwe tokens kan maken indien nodig, meestal wanneer iemand $1 op reserve stort.</p>
<h4 id="h4-Brandend20of20deflatoire20emissies658972"><a name="Brandend of deflatoire emissies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brandend of deflatoire emissies</h4><p>Sommige tokens zijn ontworpen om een deflationair emissietarief te hebben, wat betekent dat de totale voorraad van de token in de loop van de tijd afneemt. Dit kan worden bereikt via een proces genaamd ‘verbranding’, waar tokens permanent uit omloop worden verwijderd.</p>
<p>Deflatoire emissies kunnen worden gebruikt om de waarde van een token te verhogen door het aanbod te verminderen. Een voorbeeld van een deflatoire token is <a href="/price/bittorrent-btt" target="_blank" class="blog_inner_link">BitTorrent</a> Token (BTT) - de inheemse token van het gedecentraliseerde bestandsdelingsplatform BitTorrent. BTT-tokens worden verbrand telkens wanneer ze worden gebruikt om inhoud of diensten op het BitTorrent-platform te kopen, wat het totale aanbod van BTT vermindert en na verloop van tijd de waarde ervan verhoogt.</p>
<h4 id="h4-Inflationair217997"><a name="Inflationair" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inflationair</h4><p>In tegenstelling tot het deflatoire model worden inflatoire tokens gekenmerkt door een toename van hun totale aanbod in de loop van de tijd, wat kan leiden tot een daling van hun waarde als de marktvraag niet wordt gehandhaafd. Ze kunnen ook worden vergeleken met Fiat, dat ook typisch inflatoir is, omdat centrale banken nieuwe eenheden van valuta kunnen creëren om aan de respectieve vraag te voldoen.</p>
<p>Doge is een voorbeeld van een inflatoire cryptocurrency. Het heeft een vaste blockbeloning van 10.000 Doge per block, met de blocktijd ingesteld op 1 minuut. Dit betekent dat de emissiesnelheid van Doge ongeveer 144 miljoen DOGE per dag is. De maximale voorraad Doge is niet vast, en het wordt geschat dat het rond 129 miljard Doge zal bereiken in 2033. Het is vermeldenswaard dat de inflatiegraad voor <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> in de loop van de tijd kan veranderen, afhankelijk van de algehele vraag naar de token.</p>
<h4 id="h4-Dynamische20emissies101531"><a name="Dynamische emissies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dynamische emissies</h4><p>Dynamische emissies verwijzen naar een emissieontwerp dat in de loop van de tijd flexibel kan veranderen. Dit staat in contrast met vaste emissies, waarbij het uitgiftepercentage van tokens vooraf is bepaald en niet verandert, of variabele emissies, waarbij het uitgiftepercentage van tokens handmatig kan worden aangepast. Dynamische emissies kunnen worden gebruikt om een ​​verscheidenheid aan doelen te bereiken, zoals het handhaven van de waarde van de cryptocurrency, het stimuleren van gewenst gedrag, of het aanpassen aan veranderende marktomstandigheden. Zo zou een cryptocurrency met dynamische emissies bijvoorbeeld de emissiesnelheid kunnen verhogen tijdens periodes van lage vraag om adoptie te stimuleren en de waarde van de token te verhogen. Daarentegen kan het de emissiesnelheid verlagen tijdens periodes van hoge vraag om het risico van overaanbod te verminderen en de waarde van de token te handhaven.</p>
<p>Over het algemeen kunnen dynamische emissies een waardevol instrument zijn voor het beheren van het aanbod en de vraag van een cryptocurrency, maar ze kunnen ook complex en moeilijk te implementeren zijn. Het succes van een dynamisch emissiemodel is afhankelijk van verschillende factoren, waaronder de specifieke triggers en voorwaarden die worden gebruikt om de emissiesnelheid aan te passen en de algehele vraag naar de token.</p>
<p>Een voorbeeld van een project voor gedecentraliseerde financiën (DeFi) dat een dynamisch emissiemodel gebruikt, is <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> (COMP). Compound is een protocol dat gebruikers in staat stelt om rente te verdienen op hun tokens door ze uit te lenen aan leners of door te lenen van andere gebruikers. De inheemse token, COMP, wordt gebruikt om het protocol te reguleren en transacties op het platform te vergemakkelijken.</p>
<p>De emissiesnelheid van COMP wordt aangepast op basis van verschillende factoren, waaronder het totale aanbod van COMP, de vraag naar COMP en het algemene gebruik van het Compound-protocol. Als bijvoorbeeld het totale aanbod van COMP laag is en de vraag naar COMP hoog is, kan de emissiesnelheid van COMP worden verhoogd om de adoptie te stimuleren en de waarde van de token te verhogen. Daarentegen, als het totale aanbod van COMP hoog is en de vraag naar COMP laag is, kan de emissiesnelheid van COMP worden verlaagd om het risico van overaanbod te verminderen en de waarde van de token te behouden.</p>
<h4 id="h4-Algemene20principes20om20te20volgen867373"><a name="Algemene principes om te volgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Algemene principes om te volgen</h4><p>Enkele principes om in gedachten te houden bij het ontwerpen of analyseren van een token-emissiemodel zijn:</p>
<p>Stem de prikkels af op de doelstellingen van het project: Het token-uitgiftemodel moet worden ontworpen om de prikkels van belanghebbenden af te stemmen op de doelstellingen van het project. Dit helpt ervoor te zorgen dat alle belanghebbenden naar dezelfde doelstellingen werken en dat de waarde van het token in de loop van de tijd wordt behouden.</p>
<p>Behoud de waarde van de token: Het token emissiemodel moet zo worden ontworpen dat het helpt om de waarde van de token in de loop van de tijd te behouden. Dit kan worden bereikt door middel van een combinatie van factoren, zoals het beperken van het totale aanbod van de token, het controleren van het tempo van tokenuitgifte en het structureren van pragmatische prikkels.</p>
<p>Zorg voor netwerkbeveiliging: Het emissiemodel van tokens moet zo ontworpen zijn dat het deelname en samenwerking tussen belanghebbenden stimuleert, terwijl het ook mogelijke aanvallen of kwaadwillig gedrag aanpakt. Dit kan helpen om de veiligheid en integriteit van het netwerk te waarborgen.</p>
<p>Wees transparant en voorspelbaar: Het emissiemodel van de token moet transparant en voorspelbaar zijn, zodat belanghebbenden kunnen begrijpen hoe de token wordt uitgegeven en welke factoren invloed hebben op de waarde ervan. Dit kan helpen om vertrouwen en vertrouwen in het bezit op te bouwen.</p>
<p>Houd rekening met externe factoren: Het emissiemodel van de token moet rekening houden met externe factoren die van invloed kunnen zijn op de waarde van de token, zoals regelgevende ontwikkelingen, marktomstandigheden en technologische vooruitgang.</p>
<p>Over het algemeen hangt het succes van een tokenemissiemodel af van een verscheidenheid aan factoren, en het is belangrijk om de specifieke doelen en behoeften van het cryptocurrencyproject in overweging te nemen bij het ontwerpen van het model.</p>