MjAyNSBNdXN0LUhhdmUgdm9vciBOaWV1d2tvbWVycyBpbiBDcnlwdG8gQWN0aXZhOiBXYXQgemlqbiBMYXllciAwLCBMYXllciAxIGVuIExheWVyIDI/

2021-11-24, 03:44

<p><img src="https://gimg2.gateimg.com/image/6202506061330523020188472.webp" alt="">
</p><h2 id="h2-Laatste20ontwikkelingen20in202025418489"><a name="Laatste ontwikkelingen in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste ontwikkelingen in 2025</h2><p>In 2025 is de gelaagde architectuur van blockchain aanzienlijk geëvolueerd door nieuwe ontwikkelingen in Layer 0, Layer 1 en Layer 2-oplossingen:</p>
<ul>
<li><p>Laag 0-integratie: Belangrijke infrastructuurprotocollen zoals <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> en Cosmos hebben naadloze interoperabiliteit tussen heterogene blockchains bereikt, met meer dan 200 parachains die nu opereren in meerdere ecosystemen.</p>
</li><li><p>Laag 1 Efficiëntie: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> heeft de Surge-upgrade met succes voltooid, waardoor de transactiedoorvoer met 100 keer is verhoogd terwijl de decentralisatieprincipes behouden blijven.</p>
</li><li><p>Laag 2 Volwassenheid: Rollup-technologie is gestandaardiseerd, ZK-rollups verwerken 85% van de Ethereum-transacties en de kosten zijn met 98% gedaald vergeleken met de niveaus van 2023.</p>
</li></ul>
<p>De markt heeft positief gereageerd op deze ontwikkelingen:</p>
<table>
<thead>
<tr>
<th>Laagtype</th>
<th>TVL Groei (t.o.v. 2023)</th>
<th>Actieve Gebruikers</th>
<th>Gemiddelde Transactiekosten</th>
</tr>
</thead>
<tbody>
<tr>
<td>Laag 0</td>
<td>+350%</td>
<td>15 miljoen+</td>
<td>$0,005</td>
</tr>
<tr>
<td>Laag 1</td>
<td>+210%</td>
<td>110 miljoen+</td>
<td>$0,05</td>
</tr>
<tr>
<td>Layer 2</td>
<td>+800%</td>
<td>250 miljoen+</td>
<td>$0.001</td>
</tr>
</tbody>
</table>
<p>Cross-layer oplossingen zijn de industriestandaard geworden, waardoor applicaties naadloos over meerdere lagen kunnen draaien. Platformgegevens tonen aan dat gebruikers migreren naar geïntegreerde oplossingen die de beveiliging van Layer 1 en de prestatievoordelen van Layer 2 benutten.</p>
<p>De uitdaging van de onmogelijke driehoek heeft de theoretische discussies overschreden, met praktische implementaties die een ongekende balans tonen tussen veiligheid, decentralisatie en schaalbaarheid door een hybride benadering die de voordelen van verschillende lagen combineert.</p>
<h2 id="h2-Een20mustread20voor20nieuwelingen20in20de20wereld20van20cryptoactiva20Wat20zijn20Layer20020Layer20120en20Layer202253257"><a name="Een must-read voor nieuwelingen in de wereld van crypto-activa: Wat zijn Layer 0, Layer 1 en Layer 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een must-read voor nieuwelingen in de wereld van crypto-activa: Wat zijn Layer 0, Layer 1 en Layer 2</h2><p>[TL; DR]</p>
<ol>
<li>De blockchain heeft een zeslaagse architectuur: datalaag, netwerklaag, consensuslaag, incentivelaag, contractlaag en applicatielaag.</li><li>De datalaag en netwerklaag zijn de fundamentele architectuur van de blockchain en vormen ook de laagste laag van het hele blockchain-systeem.</li><li>Bovenop de basisarchitectuur vormen de consensuslaag, incentivelaag, contractlaag en applicatielaag samen het protocolgedeelte van de blockchain.</li><li>Laag 0, ook bekend als de gegevensoverdrachtlaag, komt overeen met de onderste laag van het OSI-model en betreft voornamelijk de integratieproblemen tussen blockchain en traditionele netwerken.</li><li>Layer 1-schaaloplossingen, ook wel on-chain-schaaloplossingen genoemd, verwijzen naar schaaloplossingen die zijn geïmplementeerd op het basisprotocol van de blockchain.</li><li>Laag 2 schalingsoplossingen, ook wel bekend als off-chain schaling, verwijzen naar het verhogen van de verwerkingsnelheid van transacties door middel van methoden zoals state channels en sidechains zonder de onderliggende blockchainprotocol en fundamentele regels te veranderen.</li></ol>
<p>In het nieuws over crypto-activa zijn schaalbaarheid, Layer 0/1/2 ongetwijfeld een reeks termen die vaak worden genoemd. Wat zijn de Layer 0, Layer 1 en Layer 2 van blockchain, en wat zijn de verschillende kenmerken en toepassingen van deze drie lagen?</p>
<h2 id="h2-Beginnen20met20de20zeslaagse20architectuur20van20de20blockchain963762"><a name="Beginnen met de zeslaagse architectuur van de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beginnen met de zeslaagse architectuur van de blockchain</h2><p>In januari 2009 genereerde de mysterieuze geek Satoshi Nakamoto de Bitcoin-blok op een server in Helsinki. Tegenwoordig is <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> geëvolueerd tot een enorm systeem met tienduizenden knooppunten wereldwijd en een totale marktwaarde van meer dan $1 biljoen. Bitcoin lost perfect het probleem van waarde-representatie in de digitale wereld op en heeft de blockchain-technologie aan de mensheid gebracht. Als we de structuur van het Bitcoin-systeem zorgvuldig analyseren, kan het worden onderverdeeld in vijf lagen op basis van functionaliteit: de datalaag, de netwerlaag, de consensuslaag, de incentive-laag en de applicatielaag. Vervolgens heeft Ethereum, dat snel opkwam door slimme contracten, een nieuw paradigma voor blockchain-systemen vastgesteld door een contractlaag toe te voegen tussen de incentive-laag en de applicatielaag. Laat ons dit in detail uitleggen van onder naar boven.</p>
<p>De datalaag en de netwer laag zijn de fundamentele architectuur van de blockchain en ze zijn ook de onderste laag van het gehele blockchain systeem.</p>
<p>De Data Layer omvat de datastructuren van elk blok, zoals de Merkle-boom, evenals hoe verschillende blokken end-to-end zijn verbonden om een keten te vormen. Daarnaast omvat de Data Layer ook de hash-encryptie-algoritmen en asymmetrische encryptie-algoritmen die worden gebruikt om de onveranderlijkheid van de blockchain te waarborgen. De blockchain-data layer kan worden gezien als een database met gedistribueerde kenmerken en onveranderlijkheid. Deze gedistribueerde database moet gezamenlijk worden onderhouden door alle knooppunten van het systeem, wat leidt tot de netwerklaag van de blockchain.</p>
<p>De netlaag (Netwerklaag) beschrijft een enorm P2P-netwerk dat is samengesteld uit alle knooppunten in de blockchain. In dit gedistribueerde, punt-tot-punt netwerk, zodra een knooppunt een nieuw blok aanmaakt, verzendt het de informatie naar verschillende nabijgelegen knooppunten via een broadcastmechanisme (Transmissiemechanisme). Andere knooppunten, nadat ze de verificatie van het blok hebben voltooid (Authenticatiemechanisme), zullen opnieuw de gegevens naar andere knooppunten verzenden. Uiteindelijk, nadat de meerderheid van de knooppunten in het gehele systeem de verificatie van het blok heeft voltooid, wordt het blok officieel verbonden met de blockchain.</p>
<p>Bovenop de basisarchitectuur vormen de consensuslaag, incentive-laag, contractlaag en applicatielaag samen het protocolgedeelte van de blockchain.</p>
<p>De Consensuslaag omvat voornamelijk de consensusmechanisme-algoritmen van de blockchain. In een blockchain-netwerk bereiken veel oorspronkelijk niet-verbonden knooppunten eenheid via consensusalgoritmen, waardoor de consistentie van de datalaag wordt behouden. Momenteel zijn de meest voorkomende consensusmechanismen de Proof of Work (PoW) die door Bitcoin wordt gebruikt en de Proof of Stake (PoS) die door Ethereum 2.0 wordt gebruikt. <a href="https://www.gate/cn/trade/EOS_USDT?ch=ann357" rel="nofollow noopener noreferrer" target="_blank">EOS</a> Het gedelegeerde bewijs van inzet (Gedelegeerd<br>Bewijs van Inzet,<br>DPoS) dat wordt toegepast, enz. Het consensusmechanisme is een van de kerninnovaties van blockchain-technologie, die een aanzienlijke impact heeft op de beveiliging en operationele efficiëntie van het systeem. Bovendien zijn consensusalgoritmen ook de belangrijkste middelen voor gemeenschapsbestuur in blockchain.
</p><p>De Actuator Laag omvat voornamelijk het Uitgiftemechanisme en het Distributiemechanisme van de blockchain. Door het ontwerp van het beloningsmechanisme zullen knooppunten in het systeem vrijwillig de beveiliging van het gehele blockchain-netwerk handhaven. Bijvoorbeeld, in het Bitcoin PoW-mechanisme worden nieuw uitgegeven bitcoins verdeeld onder de mijnwerkers van de pakkende knooppunten. De consensus wordt bereikt op een manier die dicht bij “hoe harder je werkt, hoe meer je verdient” ligt; knooppunten met meer rekenkracht hebben een grotere kans om succesvol blokken te verpakken en dus het recht op boekhouding te verwerven. In sommige beloningsmechanismen kunnen knooppunten die hun macht misbruiken ook door het systeem worden bestraft.</p>
<p>Bitcoin integreert op creatieve wijze economische stimulansmechanismen in algoritmen, waardoor miners kunnen concurreren om boekhoudrechten via rekenkracht. Dit onderhoudt niet alleen het transactiesysteem, maar geeft ook nieuwe tokens uit, die vervolgens als stimulansen aan miners worden verdeeld, waardoor een stabiele en veilige gesloten lus ontstaat. In dit proces wordt ook de functionaliteit van Bitcoin als elektronische contanten gerealiseerd. Laten we blijven voortschrijden naar de bovenste laag.</p>
<p>De Contractlaag omvat voornamelijk verschillende scriptcodes, algoritmen en slimme contracten, en het is de basis voor de implementatie van veel geavanceerde functies in blockchain. In blockchain realiseert het werkelijk de zogenaamde “code is wet”; zodra het contractalgoritme wordt geactiveerd, zal het onvermijdelijk draaien volgens de oorspronkelijke instellingen zonder enige tussenkomst of bevordering van derde partijen. Bovendien, vanwege de Turing-compleetheid van slimme contracten, beschikt de contractlaag ook over programmeerbaarheid, wat het hele blockchain-netwerk een natuur geeft die vergelijkbaar is met die van een virtuele machine.</p>
<p>De Toepassingslaag is de bovenste laag van het gehele blockchain-systeem en omvat verschillende toepassingsscenario’s van die blockchain. Voor de Bitcoin-blockchain vormen de volledige uitgifte-, overdrachts- en boekhoudfuncties van het Bitcoin-elektronische contantsysteem de “Toepassingslaag”; terwijl voor een programmeerbare blockchain zoals Ethereum veel geavanceerde functies en talloze DApps samen de toepassingslaag vormen.</p>
<h2 id="h2-Laag20020Laag20120en20Laag202858468"><a name="Laag 0, Laag 1 en Laag 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laag 0, Laag 1 en Laag 2</h2><p>De zes niveaus van het blockchain-systeem zijn in structuur nauw met elkaar verbonden en realiseren gezamenlijk de functies van blockchain. Terugkomend op het schaalbaarheidsprobleem dat aan het begin van dit artikel werd genoemd, verwijst de industrie over het algemeen naar het Open Interconnection Reference Model (OSI) in het communicatiedomein, waarbij de zes niveaus van het blockchain-systeem opnieuw worden gecategoriseerd in drie lagen, namelijk Laag 0, Laag 1 en Laag 2, van onder naar boven.</p>
<p>Onder hen verwijst Layer 0, ook bekend als de dataoverdrachtslaag, naar de onderste laag van het OSI-model en betreft voornamelijk de integratieproblemen tussen blockchain en traditionele netwerken. De bijbehorende Layer 0-uitbreidingsoplossingen verwijzen naar prestatieverbeteringsoplossingen die de blockchainstructuur niet wijzigen en de oorspronkelijke ecologische regels behouden. Aangezien het de blockchain zelf niet beïnvloedt, hebben Layer 0-uitbreidingsoplossingen sterke veelzijdigheid. Tegelijkertijd zijn Layer 0-uitbreidingsoplossingen ook compatibel met Layer 1⁄2uitbreidingsoplossingen, samenwerken om de prestaties van blockchain-netwerken exponentieel te verbeteren. In de onderliggende netwerkprotocollen zijn er nog veel prestatiegerelateerde problemen die het waard zijn om te optimaliseren. Momenteel omvatten de bestaande Layer 0 uitbreidingstechnologie richtingen zoals BDN (Gedistrubueerd Netwerk), QUIC UDP-protocol, enz.</p>
<p>Bovendien wordt Polkadot vaak aangeduid als een Layer 0 blockchain. Dit komt omdat het Polkadot mainnet, als relay chain, alleen dient om veiligheid en interoperabiliteit tussen verschillende parachains te bieden. Bovenop Polkadot is het mogelijk om Layer 1 blockchains, vergelijkbaar met Ethereum, via slots te koppelen, zoals de Moonbeam-keten, die ook de Solidity-taal ondersteunt.</p>
<p>Laag 1 komt overeen met de datalaag, netwerklaag, consensuslaag en incentivelaag in het zeslagenmodel. Voor de meeste crypto-activa is Laag 1 de enige publieke keten en vinden alle transactieafrekeningen hier plaats. Oplossingen voor opschaling van Laag 1, ook bekend als opschaling op de keten, verwijzen naar opschalingsoplossingen die zijn geïmplementeerd op het blockchain-basislaagprotocol. Over het algemeen vereist het het aanpassen van inherente eigenschappen zoals blokcapaciteit, blokgeneratietijd en consensusmechanisme om de transactiecapaciteit te verbeteren. Specifiek verhoogt de upgrade van de blokgrootte van Bitcoin de capaciteit van elk Bitcoin-blok, waardoor er meer transacties kunnen worden verwerkt; Bitcoin SegWit vermindert de ruimte die door de gemiddelde enkele transactie wordt ingenomen, waardoor elk blok een groter aantal transacties kan bevatten; upgraden naar DPoS kan ook betere prestaties opleveren ten koste van een bepaalde mate van decentralisatie en veiligheid. Echter, door fysieke en economische beperkingen heeft de efficiëntie van de opschaling van Laag 1 zijn grenzen.</p>
<p>Voor de principes en beperkingen van Layer 1-schaalbaarheid, verwijzen wij naar onze vorige blogpost:</p>
<p><a href="https://www.gate/blog_detail/86/dogecoin-
why-is-vitalik-buterin-against-it-will-scaling-increase-its-popularity" rel="nofollow noopener noreferrer" target="_blank">Wat zei V God in zijn artikel waarin hij Musk tegenwerpt? Kan schaling Dogecoin de “volksvaluta” maken?</a></p>
<p>Laag 2 correspondeert met de contractlaag en applicatielaag van de blockchain. Laag 2 schalingoplossingen, ook wel bekend als off-chain schaling, verwijzen naar het verbeteren van de snelheid van transactieprocessing zonder de onderliggende protocollen en basisregels van de blockchain te wijzigen, door middel van oplossingen zoals state channels en sidechains. Laag 2 breidt extern uit naar de hoofdketen en heeft een complementaire relatie met Laag 1; dat wil zeggen, Laag 2 is de infrastructuur die bovenop de onderliggende blockchain is gebouwd en biedt betere schaalbaarheid, bruikbaarheid en privacy voor de blockchain. In vergelijking met Laag 1, die streeft naar beveiliging en decentralisatie, richt Laag 2 zich op ultieme efficiëntie en prestaties. Momenteel omvatten veelvoorkomende Laag 2-oplossingen Side Chain, Plasma, state channels en Rollup.</p>
<p>Voor veelvoorkomende Layer 2-oplossingen op Ethereum, verwijzen we naar onze vorige blogpost: <a href="https://www.gate/blog_detail/77/ethereum-layer-2-an-
upgrade-of-scalability" rel="nofollow noopener noreferrer" target="_blank">Hoe te spelen met Ethereum Layer 2? Begrijp de schaalupgrade van Ethereum in één artikel.</a></p>
<h2 id="h2-Conclusie345977"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Sinds de snelle ontwikkeling van Bitcoin en Ethereum is het probleem van onvoldoende prestaties altijd een donkere wolk geweest die boven gevestigde publieke ketens hangt. Hoe de “onmogelijke driehoek” te doorbreken en de optimale oplossing te bereiken tussen schaalbaarheid, decentralisatie en beveiliging wordt ook wel de “Heilige Graal” in het blockchain-veld genoemd.</p>
<p>In de volgende artikelen zullen we specifiek verschillende blockchain-uitbreidingsoplossingen introduceren, terwijl we de voorhoede van de industrie volgen en de nieuwste ontwikkelingen in schaaltechnologie rapporteren. Blijf op de hoogte.</p>
<div class="blog-details-info"><br>  <div>Auteur: Blog Team<br>  <div class="info-tips"><em>Deze inhoud 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 mogelijk al zijn of een deel van zijn diensten kan beperken of verbieden vanuit beperkte gebieden. Lees de gebruikersovereenkomst voor meer informatie, link:<a  rel="nofollow noopener noreferrer"  href="https://www.gate/zh/user-agreement。" data-index="4"></a><a  rel="nofollow noopener noreferrer"  href="https://www.gate/zh/user-agreement" data-index="5">https://www.gate/zh/user-agreement</a>.<br><p></p><br></em></div></div></div>