RGUgbWFya3QgaXMgdm9sYXRpZWwsIFdhdCB6aWpuIGRlIGhvb2d0ZXB1bnRlbiB2YW4gZGUgcmVsYXRpZWYgc3RlcmtlIFJXQS1zZWN0b3I/

2025-02-13, 08:06

<p><img src="https://gimg2.gateimg.com/image/article/1739433535newindustryanalysis.jpeg" alt=""></p>
<h2 id="h2-TLDR933977"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De RWA-sector heeft het recentelijk goed volgehouden <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> correctie en is een van de weinige sectoren die bestand zijn tegen dalingen.</p>
<p>RWA-projecten zoals Ondo Finance bevorderen de tokenisatie van real-world assets door technologische innovatie, lossen compliance-issues op en realiseren een efficiënte circulatie van assets.</p>
<p>Met de steun van echte rendementen en institutionele goedkeuring heeft RWA de langdurige vitaliteit aangetoond om te overleven in stieren- en berenmarkten, en is het een kernhub geworden die de traditionele financiën en het on-chain ecosysteem verbindt.</p>
<h2 id="h2-Introductie188685"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Toen de markt werd verkocht en verschillende sectoren werden teruggetrokken, leidde de RWA-sector de markt met zijn unieke veerkracht en stabiliteit, en werd opnieuw de markthotspot na Meme en AI. Dit artikel zal diepgaand ingaan op de opkomst van de RWA-sector, hoe projecten vertegenwoordigd door Ondo Finance de ontwikkeling van RWA-tokenisatie bevorderen, en de brede vooruitzichten van de RWA-sector in de toekomstige financiële markt analyseren.</p>
<h2 id="h2-De20markt20is20relatief20koud20en20de20RWAsector20is20relatief20sterk801635"><a name="De markt is relatief koud en de RWA-sector is relatief sterk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De markt is relatief koud en de RWA-sector is relatief sterk</h2><p>Sinds het begin van februari heeft de cryptomarkt een diepe correctie ondergaan. Volgens gegevens daalde de markt op 3 februari, toen het op zijn slechtst was, tot onder de $90.000, terwijl ETH, die traag was geweest, daalde tot $2.100. Ook DeFi, Meme, AI en andere sectoren kelderden.</p>
<p>De RWA-sector steeg echter lichtjes tegen de trend in en werd een van de weinige tracks die de daling weerstond. Daaronder Mantra (OM), dat zich richt op RWA-laag 1, en Ondo Finance (ONDO), de leider in RWA-infrastructuur, herstelden snel te midden van het herstel van het marktsentiment, en toonden sterke veerkracht.<img src="https://gimg2.gateimg.com/image/article/17394337651.jpeg" alt=""><br>Bron: CoinMarketCap</p>
<p>De recente prestaties van de cryptomarkt zijn nauw verbonden met de macro-economische marktomgeving. Met de invoering van tarieven door de regering-Trump en de opschorting van renteverlagingen, hoewel het nieuws binnen de marktverwachtingen viel, duwde het nog steeds de Amerikaanse dollarkoers omhoog, en de goudprijs bereikte in dezelfde periode een recordhoogte.</p>
<p>Ondertussen, hoewel de cryptomarkt is hersteld als gevolg van het herstel van Amerikaanse technologieaandelen, is de interesse van investeerders in dergelijke hoogvolatiele activa verzwakt, en hebben zij hun aandacht verlegd naar gebieden met meer stabiele rendementsverwachtingen. In deze context is RWA een belangrijke keuze geworden voor sommige bestaande fondsen om risico’s af te dekken vanwege de sterke correlatie met de traditionele financiën, de compliancekenmerken en de echte rendementsattributen.<img src="https://gimg2.gateimg.com/image/article/17394337862.jpeg" alt=""><br>Bron: BCG</p>
<p>Achter de differentiatie van marktsentiment ligt de stille opzet van institutionele fondsen. Sinds 2024 heeft de totale marktwaarde van on-chain getokeniseerde activa 16 miljard dollar overschreden, waarvan hoogkredietgerangschikte activa zoals Amerikaanse schatkistbons meer dan 30% uitmaken. McKinsey voorspelt dat de omvang van getokeniseerde activa tegen 2030 $16 biljoen kan bereiken, terwijl Boston Consulting Group zelfs een optimistische voorspelling van $30 biljoen geeft.<img src="https://gimg2.gateimg.com/image/article/17394338173.jpeg" alt=""><br>Bron: rwa.xyz</p>
<h2 id="h2-Van20concept20tot20praktijk20RWA20opent20de20grenzen20van20crypto20verbeelding901761"><a name="Van concept tot praktijk, RWA opent de grenzen van crypto verbeelding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Van concept tot praktijk, RWA opent de grenzen van crypto verbeelding</h2><p>Vorig jaar hebben we het verleden en heden van de RWA-sector geïntroduceerd in “ <a href="https://www.gate.io/blog/4233/rwa-track-dominates-screen-again-everything-you-need-to-know-about-new-opportunities" target="_blank">RWA Track domineert het scherm opnieuw, Alles wat je moet weten over nieuwe kansen</a> We zullen het nogmaals kort uitleggen om het voor lezers gemakkelijker te maken om de context te begrijpen.</p>
<p>RWA, of Real World Assets, verwijst naar het proces van het omzetten van traditionele financiële activa (zoals aandelen, obligaties en onroerend goed) in on-chain digitale tokens via blockchaintechnologie. De kernwaarde ervan ligt in het doorbreken van geografische en liquiditeitsbeperkingen en het bereiken van een efficiënte circulatie en combinatie van activa.</p>
<p>Naar soorten activa kan RWA worden verdeeld in vastrentende waarden, aandelen, fysieke activa, alternatieve activa, enz. Onder hen zijn vastrentende producten voornamelijk gebaseerd op Amerikaanse schatkistobligaties en bedrijfsobligaties goed voor meer dan 70% van de huidige RWA-markt.<img src="https://gimg2.gateimg.com/image/article/17394338514.jpeg" alt=""><br>Bron: Yash Agarwal</p>
<p>Neem Ondo Finance als voorbeeld. Het project lanceerde in februari innovatieve producten zoals Ondo Chain en Ondo Global Markets, en bevorderde actief de ontwikkeling van RWA-tokenisatie.</p>
<p>Ondo Chain: Ondo Chain is een institutionele RWA L1-blockchain die de openheid van openbare blockchains combineert met de nalevings- en beveiligingskenmerken van toestemming verlenende netwerken om de grootschalige invoering van RWA te stimuleren.</p>
<p>Ondo Global Markets: Het Ondo Global Markets (OGM) platform stelt gebruikers in staat om Amerikaanse aandelen (zoals Apple, Uber, enz.) 1:1 te tokenizen en ondersteunt24⁄7handelsnetwerk. Via slimme contracten kunnen deze getokeniseerde activa naadloos worden verbonden met het DeFi-protocol voor lenen, staking of derivatenhandel, waardoor een <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">samengesteld</a> inkomensscenario van “RWA+DeFi” en het oplossen van de nalevingskwesties van dergelijke producten in het verleden.<br><img src="https://gimg2.gateimg.com/image/article/17394338775.jpeg" alt=""><br>Bron: Ondo Finance</p>
<p>Natuurlijk vereist de ontkoppeling van RWA niet alleen technologische doorbraken, maar ook nalevingskwesties. Neem Ondo Chain als voorbeeld, de L1 blockchain neemt een hybride architectuur aan: verificatieknooppunten moeten een vergunning hebben (bediend door Franklin Templeton, Google Cloud en andere instellingen) om te zorgen voor naleving van antiwitwas- (AML) en effectenregelgeving; en de on-chain toepassingslaag is volledig open, waardoor ontwikkelaars vrij activa kunnen uitgeven of slimme contracten kunnen implementeren. Deze ontwerp voldoet niet alleen aan de strenge nalevingsvereisten van instellingen, maar behoudt ook de openheid van de blockchain.</p>
<h2 id="h2-Met20de20komst20van20instellingen20overtreft20RWA20Meme20om20een20langetermijnverhaal20te20worden697747"><a name="Met de komst van instellingen overtreft RWA Meme om een langetermijnverhaal te worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met de komst van instellingen overtreft RWA Meme om een langetermijnverhaal te worden</h2><p>Het huidige knelpunt van het RWA-ecosysteem is dat “het gemakkelijk in de keten te zetten is, maar moeilijk te versterken.” Met andere woorden, tokenisatie is slechts de eerste stap. Om ervoor te zorgen dat activa samengestelde waarde genereren in de keten, zijn nog steeds doorbraken in onderliggende technologieën nodig.</p>
<p>Neem bijvoorbeeld Plume, het recentelijk populaire RWA Layer1-netwerk. De publieke keten heeft traditionele instellingen zoals UBS en Blackstone aangetrokken door middel van zijn modulaire ontwerp. Zo verbindt UBS bijvoorbeeld getokeniseerd goud met het <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a>-protocol via de API-interface van Plume, en gebruikers kunnen GLD-tokens inzetten om stabielecoinleningen te verkrijgen met een geannualiseerd rendement van 8%.<br><img src="https://gimg2.gateimg.com/image/article/17394339026.jpeg" alt=""><br>Bron: Plume</p>
<p>Natuurlijk staat RWA nog steeds voor meerdere langetermijnuitdagingen:</p>
<p>Regelgevingsfragmentatie: Verschillende rechtsgebieden hanteren verschillende normen voor het identificeren van getokeniseerde activa. De Amerikaanse SEC beschouwt sommige RWAs als effecten, terwijl de EU MiCA-wet strenge naleving van bewaring vereist;</p>
<p>Liquiditeitsval: Nadat niet-standaard activa (zoals vastgoed) getokeniseerd zijn, is de handelsdiepte onvoldoende, wat gemakkelijk kan leiden tot prijsontkoppeling;</p>
<p>Technische kwetsbaarheden: In augustus 2024 werd de $20 miljoen aan onderpand van Centrifuge geliquideerd vanwege een kwetsbaarheid in het smart contract, waarbij de zwakte van zijn beveiligingsmechanisme aan het licht kwam.</p>
<p>In vergelijking met de overmatige speculatie van Meme coins en de hoge bubbel van AI-concepten, ligt het kernvoordeel van RWA in de echte inkomensondersteuning en institutionele goedkeuring. De ontwikkelingslogica is relatief duidelijk. Met de voordelen van stabiele inkomsten, nalevingspremie en ecosysteemuitbreiding, met name in de huidige opgewonden sfeer van pure speculatie over de ‘marktrendementdroom’, kunnen de dominante on-chain schatkistobligaties nog steeds stabiele contanten bieden. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> Dit verschil bepaalt de langetermijnlevensvatbaarheid van RWA door stieren- en berenmarkten.<br><img src="https://gimg2.gateimg.com/image/article/17394339287.jpeg" alt=""><br>Bron: DefiLlama</p>
<p>Over het algemeen is deze bull markt anders dan de kenmerken van de vorige algemene stijging van de cottage-industrie, wat aantoont dat de trend van fondsen die migreren van hoge-volatiliteitsactiva naar het veld onomkeerbaar is. De RWA-sector, vertegenwoordigd door Ondo Finance, Plume, Mantra, enz., is met zijn naleving, lage bubbel, echte inkomen en institutionele kenmerken de kernhub die traditionele financiën en het ketenecosysteem verbindt. Voor investeerders is het bouwen van deze brug niet alleen een keuze om risicoen te vermijden, maar ook een historische kans om deel te nemen aan wereldwijde financiële hervormingen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>