MjAyMyBDcnlwdG8gTWFya3QgUmV2aWV3OiBFZW4gTmlldXdlIFJlaXMgdmFuIEJlZXIgbmFhciBTdGllciAoRGVlbCAyKQ==

2023-12-27, 13:30

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR561979"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>In 2023 wordt de wereldwijde cryptomarkt steeds meer gereguleerd. Ondanks een reeks handhavingsacties tegen cryptocurrency, omarmt Hong Kong actief de cryptobranche en over het algemeen is de trend dat het Westen niet helder is en het Oosten wel.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zag een sterke stijging van 170% gedurende het hele jaar, en behield daarmee zijn leidende positie in de branche. Het spill-over effect van fondsen activeerde ook de hele crypto-markt in het vierde kwartaal, waarbij AI, DePIN, RWA en andere sectoren uitstekend presteerden.</p>
<p>In 2023 heeft de crypto markt een turbulent jaar meegemaakt, maar Gate.io heeft altijd een stabiele ontwikkelingstrend behouden. Het succes van Gate.io bewijst dat het vasthouden aan geloofwaardigheid, innovatie en maatschappelijke verantwoordelijkheid de sleutel is tot het succes van een crypto handelsplatform.</p>
<p>(Volg de voorgaande alinea)</p>
<h2 id="h2-Stablecoins824581"><a name="Stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stablecoins</h2><p>Stablecoins zijn cryptocurrencies die gekoppeld zijn aan fiatvaluta, meestal gebaseerd op Amerikaanse dollars, euro’s of ponden. Ze zijn een belangrijk instrument dat kan worden gebruikt voor handel, investeringen en betalingen.</p>
<p>In 2023 onderging de Stablecoin-markt aanzienlijke veranderingen, voornamelijk weerspiegeld in de volgende aspecten:</p>
<p>De voorraad Stablecoins daalde eerst en steeg toen. De totale voorraad Stablecoins vertoonde een voortdurende daling van maart 2022 tot oktober 2023, met een maandelijkse groeisnelheid van 3% vanaf oktober.</p>
<p>Op de schrijfdatum is de totale marktwaarde van Stablecoins hersteld tot $130.758B, wat aangeeft dat de interesse van investeerders in Stablecoins terugkeert.<img src="https://gimg2.gateimg.com/image/article/1703683521img_v3_026h_84db8065-1792-4bc9-8dc5-b2fd8be0bbix.jpg" alt=""><br>Bron: DeFilLama</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft de meeste extra aandelen uitgegeven en zijn dominante positie verder versterkt. Vanaf de eerste helft van dit jaar is de dominante positie van populaire Stablecoins zoals USDC en BUSD aanzienlijk afgenomen onder invloed van regelgevingsdruk, kapitaalrotatie en een verslechterende uitgifteomgeving. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> is opnieuw de grootste Stablecoin geworden, met een totale voorraad van meer dan $91 miljard en een marktaandeel van 70%.<img src="https://gimg2.gateimg.com/image/article/1703683551img_v3_026h_610a3a82-7a2d-46c9-ae60-6ebdedef4eix.jpg" alt=""><br>Bron: glassnode</p>
<p>Decentralized Stablecoins herstellen geleidelijk. In de berenmarkt van 2022 leidde de ineenstorting van TerraUSD (USD) tot een periode van stilte op de markt voor algoritmische Stablecoins. Maar in 2023 verbeterde deze situatie zich toen DeFi-leningleider <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> duwde aan op de adoptie van zijn Stablecoin GHO, en de op Bitcoin-ecosysteem gebaseerde DAII Stablecoin werd aan het einde van het jaar gelanceerd. Zelfs de originele <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> team stelde een 1:1 uitwisseling van UST voor nieuwe Stablecoins voor, wat de marktverwachtingen voor algoritmische Stablecoins aanwakkert.</p>
<h2 id="h2-In20een20omgeving20met20veel20interesse20betreedt20RWA20het20gezichtsveld683474"><a name="In een omgeving met veel interesse betreedt RWA het gezichtsveld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In een omgeving met veel interesse betreedt RWA het gezichtsveld</h2><p>RWA (Real World Assets), ook bekend als Real World Assets, verwijst naar activa die bestaan in de fysieke wereld buiten de keten en worden getokeniseerd voordat ze op de keten worden gekocht. Deze activa omvatten onroerend goed, obligaties, grondstoffen, aandelen, enz., Die worden getokeniseerd via blockchaintechnologie, zodat het vasthouden van tokens het bezit van overeenkomstige activa in de echte wereld vertegenwoordigt.</p>
<p>Het werkingsprincipe van RWA is om het beheer en de handel in daadwerkelijke activa te digitaliseren via blockchaintechnologie, ze om te zetten in tokens of andere digitale activa en vervolgens transacties en transfers uit te voeren op de blockchain met behulp van slimme contracten.<br><img src="https://gimg2.gateimg.com/image/article/1703683584img_v3_026h_3f93436c-b40b-448f-a35a-9a1e2eaf43ix.jpg" alt=""><br>Bron: PWC</p>
<p>Hoewel het idee om activa te tokeniseren en ze naar de keten te brengen al sinds 2017 bestaat, heeft de unieke marktomgeving dit jaar eindelijk geleid tot significante doorbraken op dit gebied.</p>
<p>In de eerste helft van 2023, met de stijging van de risicovrije rente op Amerikaanse obligaties en de pessimistische impact van de berenmarkt in de cryptomarkt, begonnen mensen op zoek te gaan naar stabielere inkomstenkanalen, waardoor er een explosieve groei ontstond in het RWA-traject.</p>
<p>Neem als voorbeeld de schatkistobligatie met de hoogste acceptatie op dit moment, de TVL van schatkistobligaties gerelateerde RWAs is dit jaar zeven keer hoger geworden, gestegen van $100 miljoen naar $784 miljoen.</p>
<p>Volgens een recent onderzoeksrapport dat is uitgebracht door Citigroup, wordt voorspeld dat tegen 2030, er $4 biljoen tot $5 biljoen aan getokeniseerde digitale effecten zal zijn, en het handelsvolume van handelsfinanciering op basis van gedistribueerde grootboektechnologie ook $1 biljoen zal bereiken. Dit duidt erop dat de RWA-markt zich nog in de beginfase bevindt en enorme groeipotentie heeft voor de toekomst.<img src="https://gimg2.gateimg.com/image/article/1703683616img_v2_d1092a3b-43b1-46d0-b3d7-4132f027f7ix.jpg" alt=""><br>Bron: rwa.xyz</p>
<p>In feite heeft RWA in de cryptobranche al enkele succesvolle glen gehad, zoals de veelgebruikte Stablecoins USDT en USDC. Deze Stablecoins bereiken een relatieve prijsstabiliteit door zich te koppelen aan activa in de echte wereld, wat belangrijke waardeondersteuning biedt voor de cryptomarkt.</p>
<p>Tijdens dit jaar waren er verschillende belangrijke RWA-trackglen die het waard waren om op te letten:</p>
<p>Direct aankoop van Amerikaanse obligaties: MakerDAO is een reus in het DeFi-veld en staat aan de voorhoede van het verkennen van het RWA-veld. Ze hebben zowel het model van directe aankoop en het aanhouden van activa (MIP65) als het model van tokenized RWA-aankoop (via Centrifuge) geprobeerd. Beide modellen combineren traditionele financiën (TradFi) en DeFi en bieden nieuwe mogelijkheden voor de toepassing van RWA.</p>
<p>Verkoop van Amerikaanse Schatkist Tokenisatieproducten: In juli 2023, <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> ecosysteem lanceerde het stUSDT-product. StUSDT is een Stablecoin gebaseerd op Amerikaanse schatkistobligaties, waarmee USDT-stakers op RWA gebaseerde opbrengsten kunnen verkrijgen.</p>
<p>Platform voor tokenisatie van vastgoed: Tokenisatie van vastgoed - tokenisatie van gedeeltelijk eigendom van vastgoed, waardoor investeerders gemakkelijk kunnen investeren. Houders hebben niet alleen gedeeltelijk eigendom, maar kunnen ook huurinkomsten van vastgoed ontvangen. RealT is bijvoorbeeld een platform dat zich richt op de tokenisatie van vastgoed, opgericht in 2019, en heeft tot op heden meer dan $52 miljoen aan vastgoedtokenisatie verwerkt.<img src="https://gimg2.gateimg.com/image/article/1703683663img_v3_026h_389bceca-19cc-43ff-8e8d-7c33dd9748ix.jpg" alt=""><br>Bron: rwa.xyz</p>
<p>Over het algemeen zal de interesse van instellingen in tokenisatie doorgaan, omdat het voordelen heeft zoals kapitaalefficiëntie, liquiditeit en risicobeheer, terwijl traditionele bedrijven een langzamere transformatie hebben en het nog te vroeg is om potentiële winnaars te kiezen. Bovendien zijn integratie en interoperabiliteit van tokenisatie cruciaal, anders zal het voor uitdagingen komen te staan.</p>
<p>De interesse in tokenisatie weerspiegelt de trend van de industrie die verschuift van pure decentralisatie naar centralisatie en semi-decentralisatie. Met de verbetering van het wettelijk kader wordt verwacht dat getokeniseerde liquiditeit verder wordt ontsloten.</p>
<h2 id="h2-L2patroon20OP20zingt20Solo20Play20ZK20klaar20om20te20lanceren212518"><a name="L2-patroon: OP zingt Solo Play, ZK klaar om te lanceren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L2-patroon: OP zingt Solo Play, ZK klaar om te lanceren</h2><p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2 Scalability Solution is een dekkingslaag die draait bovenop de bestaande Ethereum-hoofdnetwerkinfrastructuur, met voordelen zoals schaalbaarheid, lage transactiekosten en interoperabiliteit, die naar verwachting veel knelpunten in de branche zal oplossen.</p>
<p>Ethereum L2 omvat voornamelijk oplossingen zoals Rollup, Plasma, sidechains en state channels. Dit jaar hebben L2-projecten vertegenwoordigd door OP Rollup de leiding genomen in het innemen van marktaandeel, terwijl naar verwachting ZK Rollup in 2024 zal exploderen.</p>
<p>Rollup: Rollup is momenteel de meest gangbare <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L2-oplossing, die transactiegegevens verpakt in kleinere bundels en de verificatieresultaten naar de Ethereum hoofdketen uploadt. Rollup kan worden onderverdeeld in twee typen: zero knowledge proof (ZKP) Rollup en Optimistic Rollup.</p>
<p>ZKP Rollup: ZKP Rollup gebruikt zero knowledge proof om transactiegegevens te verifiëren, wat een hogere beveiliging heeft maar ook duurder is.</p>
<p>Optimistic Rollup: ZKP Rollup gebruikt Optimistic om te verifiëren dat transactiegegevens lagere kosten hebben, maar er is ook een risico op fraude.</p>
<p>Plasma: Plasma maakt gebruik van subchains om transacties te verwerken, dit zijn onafhankelijke ketens die parallel lopen aan de Ethereum-hoofdketen en kunnen communiceren met de Ethereum-hoofdketen via aggregatieprotocollen. Bijvoorbeeld, Loopering en <a href="/price/omg-network-omg" rel="nofollow noopener noreferrer" target="_blank">OMG Network</a> zijn allebei gebaseerd op de Ethereum L2-oplossing van Plasma en hebben dit jaar ook enkele updates doorgevoerd.</p>
<p>Side chain: Een side chain is een onafhankelijke chain die parallel loopt aan de Ethereum main chain en kan communiceren met de Ethereum main chain via een brugprotocol. Side chains kunnen onafhankelijk hun eigen consensusmechanismen en economische modellen ontwikkelen, met meer flexibiliteit, vertegenwoordigd door <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>.</p>
<p>Statuskanaal: Een statuskanaal is een protocol dat twee partijen in staat stelt transacties uit te voeren zonder deelname van de Ethereum-hoofdketen. Het statuskanaal kan de efficiëntie en privacy van transacties verbeteren, maar het vereist het opbouwen van een vertrouwensrelatie tussen beide partijen.</p>
<p>Uit de gegevens blijkt dat het Ethereum L2-protocol dit jaar aanzienlijke vooruitgang heeft geboekt, waarbij TVL is gestegen van $ 6 miljard aan het begin van het jaar tot $ 18,4 miljard aan het einde van het jaar, en dagelijkse actieve gebruikers van meer dan 800000. Met de implementatie en lancering van meer L2-oplossingen volgend jaar, zal de concurrentie op de markt voor L2 intenser worden. <img src="https://gimg2.gateimg.com/image/article/1703683732img_v3_026h_f22e4238-7965-491e-acda-b4da37d152ix.jpg" alt=""><br>Bron: L2BEAT</p>
<p>De volgende zijn de huidige populaire protocollen voor Ethereum L2-oplossingen:</p>
<p>Arbitrum: Arbitrum is een Ethereum L2-oplossing op basis van Optimal Rollup, met betere optimistische mechanismen en exclusieve virtuele machines, die momenteel het grootste marktaandeel innemen.</p>
<p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>: <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> is een Ethereum L2-oplossing gebaseerd op Optimistic Rollup, met lagere transactiekosten en snellere transactiesnelheden; Na de lancering van OP <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Dit jaar is het marktaandeel van het project aanzienlijk gestegen en wordt verwacht dat het Arbitrum zal inhalen.</p>
<p>StarkNet: StarkNet is een Ethereum L2-oplossing gebaseerd op ZK Rollup, die complex is om te implementeren maar een snellere verificatiesnelheid en sterke schaalbaarheid heeft.</p>
<p>ZkSync: In vergelijking met Starknet is de implementatie van ZKsync relatief eenvoudig, met lagere kosten en sterkere privacy.</p>
<p>Daarnaast is Base een van de populaire L2-netwerken die dit jaar zijn opgekomen. Het is de dark horse van dit jaar geworden met de opkomst van de duizendvoudige Turkse hondencoin Bald en het populaire sociale product Friend.tech. Het aantal gebruikers en TVL van Base blijft groeien en heeft nu ZKSync overtroffen, met hoop voor de toekomst.<img src="https://gimg2.gateimg.com/image/article/1703683804img_v3_026h_1881f4a4-dc86-45ea-8777-ea5547a45aix.jpg" alt=""><br>Bron: L2BEAT</p>
<p>Vanuit het perspectief van het concurrentielandschap zullen Optimism en Arbitrum in de L2-strijd van 2023 de leiding nemen, beide met een startvoordeel.</p>
<p>Arbitrum heeft een sterke L2-hoofdketen met sterke zakelijke gegevens, evenals een hogere prestatie Arbitrum nova. Met het enorme netwerkeffect van zijn L2 kan het talloze toepassingen genereren in de gaming- en sociale domeinen. OP heeft een groot marktaandeel veroverd, met een groot potentieel om in te halen op het gebied van ecologische vrijheid, welvaart en schaal, mede dankzij zijn vroege interventie in het veld van one-click ketenlevering en de voordelen van institutionele samenwerking.</p>
<p>Over het algemeen is het Ethereum L2-ecosysteem enigszins beknot door de concurrentie van het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Inion-ecosysteem en L1 zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Dit jaar. Het Ethereum-ecosysteem domineerde de markt niet vanwege de verwachte upgrades in Shanghai in april en Cancun in Q4, en de ETH/BTC-verhouding is ook gedaald naar een meerjarig dieptepunt. We geloven echter dat met verdere marktherstel in 2024 en de lancering van talrijke ZK-serieprojecten, de L2-sector een nieuw narratief aandachtspunt zal worden.</p>
<p>Verdere analyse van de cryptomarkt in 2023:</p>
<p><a href="https://www.gate.io/blog_detail/3631/2023-crypto-market-review-a-new-journey-from-bear-to-bull-part-1 &quot;2023 Crypto Market Review: A New Journey from Bear to Bull (Part 1" rel="nofollow noopener noreferrer" target="_blank">2023 Crypto Markt Review: Een Nieuwe Reis van Beer naar Stier (Deel 1)</a>”</p>
<p><a href="https://www.gate.io/blog_detail/3633/2023-crypto-market-review-a-new-journey-from-bear-to-bull-part-3 &quot;2023 Crypto Market Review: A New Journey from Bear to Bull (Part 3" rel="nofollow noopener noreferrer" target="_blank">2023 Crypto Markt Overzicht: Een nieuwe reis van Beer naar Stier (Deel 3)</a>”</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen in g van inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>