V2F0IGlzIFVuc3BlbnQgVHJhbnNhY3Rpb24gT3V0cHV0IChVVFhPKT8gMjAyNSBVcGRhdGU=

2022-12-26, 00:38

<h2 id="h2-Samenvatting89221"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><ul>
<li>UTXO is de resterende digitale valuta na cryptocurrency-transacties.</li><li>UTXO blijft worden verwerkt en maakt deel uit van het begin en het einde van elke transactie.</li><li>Zodra een transactie is voltooid, worden alle ongebruikte outputs opgeslagen in de database als inputs voor toekomstige transacties.</li><li>UTXO is essentieel voor het voorkomen van dubbele uitgaven op de blockchain en voor gebruikers die niet-bestaande munten uitgeven.</li><li>Tegen 2025 zal het aantal UTXO’s voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) heeft 92,3 miljoen bereikt, terwijl geavanceerde modellen zoals <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>(ADA) maakt gebruik van EUTXO om complexere slimme contracten te ondersteunen. Nieuwe platforms hebben verbeterde UTXO-systemen geïntegreerd die bescherming tegen anti-MEV bieden en transactiekosten optimaliseren, terwijl speciale beheertools de keuze van munten en privacy verbeteren.</li></ul>
<h2 id="h2-Laatste20ontwikkelingen20in202025998988"><a name="Laatste ontwikkelingen in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste ontwikkelingen in 2025</h2><p>Tegen 2025 is het UTXO-model aanzienlijk geëvolueerd, met opmerkelijke vooruitgang in implementatie en adoptie:</p>
<ul>
<li>UTXO Aantal Groei: Het aantal UTXO’s in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft een historisch hoogtepunt bereikt van 92,3 miljoen, een stijging van 9% ten opzichte van het vorige record in 2022.</li><li>Uitgebreid UTXO-model: Het EUTXO-model dat door <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> is geïntroduceerd, is breed geaccepteerd en verbetert de traditionele UTXO-mogelijkheden door functies van het accountmodel, waardoor complexere slimme contracten mogelijk worden.</li><li>Cross-platform integratie: Meerdere platforms hebben het verbeterde UTXO-systeem geïntegreerd om de beveiliging te verbeteren:</li></ul>
<table>
<thead>
<tr>
<th>platform</th>
<th>UTXO-verbetering</th>
<th>Hoofdzakelijke Voordelen</th>
</tr>
</thead>
<tbody>
<tr>
<td>Nervos Netwerk</td>
<td>Anti-MEV Bescherming</td>
<td>Voorkom front-running aanvallen</td>
</tr>
<tr>
<td><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a></td>
<td>EUTXO-model</td>
<td>Implementeer complexe, deterministische contracten</td>
</tr>
<tr>
<td><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2</td>
<td>Geoptimaliseerde UTXO-set</td>
<td>Verlaag de handelskosten met 75%</td>
</tr>
</tbody>
</table>
<ul>
<li>Geavanceerde Beheerhulpmiddelen: Nieuwe hulpmiddelen specifiek voor UTXO-beheer zijn verschenen, met Sparrow en andere portemonnees die speciale interfaces aanbieden waarmee gebruikers de selectie van munten kunnen optimaliseren en privacybescherming kunnen verbeteren.</li><li>Schaaloplossing: De implementatie van UTXO-aggregatietechnologie heeft de gemiddelde transactiegrootte van Bitcoin met 34% verminderd, waarmee de eerdere schaalbaarheidsbeperkingen worden aangepakt.</li></ul>
<p>Het UTXO-model blijft zich ontwikkelen in 2025, waarbij het de transactiebeveiliging en efficiëntie in balans houdt en tegelijkertijd de eerdere beperkingen overwint. Naarmate de blockchain-technologie volwassen wordt, blijven UTXO-gebaseerde systemen de basis van de integriteit van cryptocurrency-transacties.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672015184WhatisUnspentTransactionOutput_web.jpeg" alt="">
</p><h2 id="h2-TL20DR168171"><a name="TL: DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL: DR</h2><p>UTXO is de digitale valuta die overblijft na een cryptocurrency-transactie.<br>UTXO wordt continu verwerkt en dient als het start- en eindpunt voor elke transactie.<br>Na afloop van een transactie worden alle ongebruikte outputs in de database opgeslagen als inputs voor toekomstige transacties.<br>UTXO is cruciaal om dubbele bestedingen op de blockchain te voorkomen en ervoor te zorgen dat gebruikers geen niet-bestaande munten uitgeven.
</p><h2 id="h2-Inleiding46476"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Ongebruikte Transactie-uitgangen (UTXO) en accountmodellen zijn methoden om cryptocurrency vast te leggen, die het resterende bedrag aan tokens vertegenwoordigen dat een individu heeft na een transactie op de blockchain. Deze modellen zijn cruciaal voor hoe blockchain-architecturen een nauwkeurige grootboek bijhouden en privacy waarborgen.<br>Deze term definieert in wezen de uitkomsten van ontvangen transacties die in de toekomst kunnen worden uitgegeven.<br>De beste analogie voor UTXO is fysieke fiatvaluta. UTXO kan niet worden verdeeld in kleinere denominaties zoals munten of bankbiljetten. UTXO kan worden beschouwd als discrete stukken van de overeenkomstige tokens die worden beheerd door de privésleutel van de eigenaar. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> (BTC), <a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a>(LTC), <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Andere valuta zoals <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> (BCH) en <a href="/price/zcash-zec" rel="nofollow noopener noreferrer" target="_blank">Zcash</a> (ZEC) gebruikt het UTXO-model.</p>
<h2 id="h2-Wat20is20het20Unspent20Transaction20Output20UTXO20Model192456"><a name="Wat is het Unspent Transaction Output (UTXO) Model?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het Unspent Transaction Output (UTXO) Model?</h2><p>Het bedrag aan digitale valuta dat overblijft na een cryptocurrency-transactie wordt beschreven als Unspent Transaction Output (UTXO). Dit is vergelijkbaar met het wisselgeld dat je ontvangt na een aankoop, maar het is niet in lagere valuta denominaties. Het bestaat uit transactie-uitgangen in een database die door het netwerk is gegenereerd, waardoor niet-exacte wisseltransacties mogelijk zijn.<br>Als een boekhoudkundige maatregel wordt een deel van het totale bedrag aan cryptocurrency dat nog niet is besteed in transacties (uitgangen) gebruikt voor de volgende transactie (ingangen). Elke transactie werkt als dubbele boekhouding, met een ingang en een uitgang.
</p><p>Overweeg 10 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Word een emmer vol munten. Elke munt vertegenwoordigt een ongebruikte transactie-uitgang (UTXO). Als je Stephanie 5 BTC betaalt om iets te kopen, zal het netwerk Stephanie de hele emmer met munten geven en de “wissel” van 5 BTC die je verschuldigd bent teruggeven. Je hebt nu een UTXO ter waarde van 5 BTC, die niet verder kan worden verdeeld.</p>
<h2 id="h2-Hoe20werkt20UTXO355806"><a name="Hoe werkt UTXO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt UTXO?</h2><p>Stel je voor dat je 1,3 BTC wilt versturen van een saldo van 1,5 BTC. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Walletadres. Deze 1,5 BTC kan de output zijn van uw eerdere transacties. Bijvoorbeeld, het kan respectievelijk 0,9 BTC en 0,6 BTC zijn.</p>
<p>Uw nieuwe transactie heeft twee uitgangen: 1,3 BTC is besteed (verzonden naar de ontvanger), en 0,2 BTC is een ongebruikte uitgang die zal worden teruggestuurd naar uw adres (d.w.z. de afzender). De resterende 0,2 BTC kan op een van de volgende manieren worden gebruikt: teruggestuurd naar uw account, gebruikt als deel van de transactiekosten, of verzonden als het resterende bedrag naar iemand anders.</p>
<p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Nodes onderhouden transactiegegevens door deze outputs te volgen. Elke unspent transaction output (UTXO) gebruikt gecodeerde ScriptPubKeys om elke transactie vast te leggen, zonder dat er een specifieke gebruiker aan verbonden is. Dit stelt het netwerk in staat om het bestaan van alle gerelateerde munten te verifiëren zonder de privé-informatie van de gebruikers bekend te maken.</p>
<p>Het Belang van UTXO<br>Het concept van UTXO vereenvoudigt de boekhouding van blockchain aanzienlijk. UTXO stelt elke node in staat om informatie over ongebruikte munten bij te houden, in plaats van elke transactie te volgen en op te slaan.
</p><p>Het is effectief omdat elke munt zich alleen kan bevinden in <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Het netwerk. Dit betekent dat elke BTC in de portemonnee niet uitgegeven is; ze zijn ofwel ontvangen als mijnbeloningen of gemint als wisselgeld tijdens transacties.<br>UTXO is cruciaal om dubbele bestedingen op de blockchain te voorkomen en te voorkomen dat gebruikers niet-bestaande munten uitgeven. Elke netwerknode onderhoudt een database van elke UTXO.
</p><h2 id="h2-Wat20is20een20accountmodel682515"><a name="Wat is een accountmodel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een accountmodel?</h2><p>Betaalkaarten of bankrekeningen zijn de meest voor de hand liggende analogie voor het accountmodel. In tegenstelling tot fysieke fiatvaluta die niet in kleinere denominaties kan worden verdeeld, staat het accountmodel toe dat er een willekeurig tokenbedrag kan worden gecrediteerd (of gedebiteerd). Accountmodelportefeuilles vertegenwoordigen het totale saldo van de gebruiker, terwijl UTXO-portefeuilles de som van de UTXO’s van de gebruiker bijhouden.</p>
<p>Projecten die het accountmodel gebruiken, zijn <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH), <a href="/price/ethereum-classic-etc" rel="nofollow noopener noreferrer" target="_blank">Ethereum Classic</a> (ETC) en Ripple (XRP). In tegenstelling tot het UTXO-model vertegenwoordigen transacties in het accountmodel een enkele overdracht van fondsen of digitale valuta tussen accounts, zonder de noodzaak van extra invoer of uitvoer. Alleen een wijziging in het grootboek is vereist.</p>
<h2 id="h2-Verschillen20tussen20UTXO20en20Accountmodellen678255"><a name="Verschillen tussen UTXO- en Accountmodellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verschillen tussen UTXO- en Accountmodellen</h2><p>Hoewel UTXO- en accountmodellen hetzelfde doel hebben, hebben ze elk hun eigen voordelen en nadelen.</p>
<h3 id="h3-Schaalbaarheid673895"><a name="Schaalbaarheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Schaalbaarheid</h3><p>Het accountmodel kan het geheugen beter benutten omdat het opslaan van een enkel saldo veel minder geheugen vereist dan het opslaan van alle UTXO’s die een gebruiker bezit. Transacties in het accountmodel zijn kleiner omdat ze alleen het bedrag, de afzender, de ontvanger en de digitale handtekening vereisen. Een typische Ethereum-transactie is ongeveer 100 bytes, terwijl transacties in het UTXO-model meerdere keren groter zijn. De paralleliteit van UTXO-transacties helpt ook om UTXO-gebaseerde blockchains op te splitsen in shards en sidechains. Het UTXO-model staat outputaggregatie en definitie aan de clientzijde toe, waardoor de netwerkcomputatievereisten worden verminderd. De implementatie van het accountmodel is uitdagender omdat elke node de afzender- en ontvangeraccounts over meerdere shards moet lokaliseren.</p>
<h3 id="h3-Privacy720860"><a name="Privacy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Privacy</h3><p>Het UTXO-model maakt het wisselen tussen adressen triviaal, wat het volgen van de eigendom van munten uitdagender maakt. Nieuw gegenereerde adressen hebben geen openbare eigenaar. Daarom is vaak geavanceerde ketenanalyse vereist om <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> ze aan specifieke gebruikers. Het accountmodel houdt in dat een enkel adres opnieuw wordt gebruikt. Hierdoor maakt deze blockchain het gemakkelijker om transactiegeschiedenissen te identificeren. Aan de andere kant biedt het accountmodel in termen van vervangbaarheid een betere privacy.</p>
<h3 id="h3-Slimme20Contractfunctionaliteit220382"><a name="Slimme Contractfunctionaliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Slimme Contractfunctionaliteit</h3><p>Vanwege de vereenvoudiging en intuïtiviteit van accountgebaseerde transacties profiteert dit model enorm van de functionaliteit van slimme contracten. In vergelijking met de computationele logica van UTXO-invoer/uitvoer is de rekenkracht die nodig is om een enkele balans te verifiëren minder, waardoor het gemakkelijker wordt voor DApp-ontwikkelaars om meerpartijencontracten en -transacties te programmeren. Het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM) kan bijvoorbeeld transacties tussen meerdere slimme contracten afhandelen door hun respectieve balansen aan te passen. Het UTXO-model verbruikt aanzienlijk meer middelen omdat het expliciete UTXO-invoeren en -uitvoeren in elke transactie inhoudt. Slimme contracten geschreven met het UTXO-model moeten rekening houden met het aantal in te voeren dat moet worden samengevoegd, of welke invoeren moeten worden samengevoegd als er meerdere opties zijn.</p>
<p>•Beveiliging:<br>Validatornodes in de UTXO-blockchain, zoals <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Volg de UTXO-set om te bepalen welke munten in omloop zijn en weet wie ze bezit. Het UTXO-systeem lost het probleem van dubbele uitgaven efficiënt en betrouwbaar op, omdat elke transactie de exacte UTXO moet verwijzen die moet worden uitgegeven. Blockchains met accountmodellen zijn gevoeliger voor aanvallen en hebben vaak te maken met andere problemen zoals terugbetalingen en roodstand smart contracts.<br>Bijvoorbeeld, in 2020 verloor het Ethereum Classic-project miljoenen door een reeks dubbele uitgaven aanvallen.
</p><h2 id="h2-Conclusie299125"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het UTXO-model is een methode om transacties op de blockchain vast te leggen.<br>Vanwege de voor- en nadelen van verschillende modellen hangt de toepassing van UTXO op een blockchain af van de doelstellingen van het project.<br>Ethereum hanteert het accountmodel omdat het zich richt op het implementeren van krachtige slimme contracten, en <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Gate gebruikt het UTXO-model omdat het zich meer richt op het ontwikkelen van veilige elektronische contanten.<br>Nieuwe projecten proberen deze modellen te verbeteren. Bijvoorbeeld, Cardano (ADA), <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> (TRX), en <a href="/price/qtum-qtum" rel="nofollow noopener noreferrer" target="_blank">Qtum</a>(QTUM) probeert de voordelen van beide te combineren in een geavanceerd hybride model. Deze modellen maken het voor ontwikkelaars gemakkelijker om UTXO te gebruiken, terwijl de krachtige functies van slimme contracten behouden blijven.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van (een deel van) de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="21">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>