UldBIFRyYWNrIGRvbWluZWVydCB3ZWVyIGhldCBzY2hlcm0sIGFsbGVzIHdhdCBqZSBtb2V0IHdldGVuIG92ZXIgbmlldXdlIGthbnNlbg==

2024-06-13, 01:25

<p><img src="https://gimg2.gateimg.com/image/article/1718241707sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR14441"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Met de Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Met ETF die een groot aantal traditionele fondsen aantrekt en het Amerikaanse Congres actief discussieert over gerelateerde kwesties, heeft de RWA-sector een relatief sterke prestatie laten zien.</p>
<p>Op dit moment heeft de on-chain handel in activa zoals stablecoins en schatkistpapier de haalbaarheid van activatokenisatie aangetoond, en meer projecten onderzoeken actief de opname van meer soorten activa in het blockchain-veld.</p>
<p>Hoewel het tokeniseren van activa op niet-gelicentieerde openbare blockchains kan profiteren van on-chain liquiditeit, kan het vanwege zijn trustloze aard te maken krijgen met strikte regelgevende controle, wat momenteel de grootste uitdaging is voor cryptotechnologie om naar praktische toepassingen te gaan.</p>
<h2 id="h2-Introductie324734"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bij het verkennen van het relatief aanhoudende crypto-onderwerp te midden van de recente marktdaling en volatiliteit, moeten we een track noemen die niet minder concurrerend is dan AI, MEME en DePIN - de tokenisatie van Real World Assets (RWA).</p>
<p>Met de komst van Amerikaanse spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s is er een grote hoeveelheid fondsen in cryptovaluta de markt ingestroomd, en de sterke stijging van RWA-projecten, vertegenwoordigd door Ondo Finance (ONDO), heeft verder de aandacht gevestigd op de markthitte. In dit artikel zal de ontwikkelingsstatus van de RWA-sector en investeringsmogelijkheden verder worden toegelicht.</p>
<h2 id="h2-Nieuwe20kansen20voor20RWA20onder20het20verhaal20van20Spot20ETFs633533"><a name="Nieuwe kansen voor RWA onder het verhaal van Spot ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe kansen voor RWA onder het verhaal van Spot ETF’s</h2><p>Als we het hebben over het meest opmerkelijke verhaal van deze bullmarkt, kunnen we niet om de spot-ETF’s van Bitcoin en Ethereum heen, die steeds meer fondsen en aandacht naar de cryptomarkt hebben gebracht. ETF-producten richten zich voornamelijk op Bitcoin en Ethereum, en er zijn geen tekenen van overloop naar andere Altcoin-sectoren. Daarom zijn er de laatste tijd discussies geweest in de markt over het sterke onevenwicht tussen de mainstream en Altcoin-sectoren van deze bullmarkt.</p>
<p>De opkomst van RWA-producten heeft echter deze cognitieve onbalans overbrugd, omdat de traditionele marktkoop in de cryptomarkt stroomt via spot-ETF’s. Als maagdelijk land dat de integratie van traditionele financiële markten en cryptotechnologie bevordert, wordt RWA de meest voordelige sector in het kader van voortdurend toenemende adoptiepercentages van crypto.</p>
<p>Met name in het kader van de recente actieve discussie over de tokenisatie van reële activa door de Financial Services Digital Assets Subcommittee van het Amerikaanse Huis van Afgevaardigden, en de stijging van het rendement van 10-jaars staatsobligaties, is RWA naar voren gekomen als een relatief onafhankelijke sterke prestatie.<br><img src="https://gimg2.gateimg.com/image/article/17182417921.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Vanuit een breder perspectief, met meerdere vertragingen in de regelgeving en de verwachting van een los monetair beleid, zoeken grote marktinvesteerders naar robuustere, risicovrije investeringsmogelijkheden. Tegelijkertijd hebben macro-economische veranderingen en de stijging van de Amerikaanse obligatierendementen de tokenisatie van echte wereldactiva tot een schitterende ster in de cryptomarkt gemaakt, waardoor het een belangrijk kanaal is geworden voor investeerders om waarde te creëren.</p>
<p>In feite is de markt vanuit een breder ontwikkelingsperspectief op zoek geweest naar manieren om echte wereldse activa op de keten te brengen sinds de opkomst van blockchaintechnologie. Tegenwoordig proberen bekende traditionele financiële instellingen zoals Goldman Sachs, Hamilton Alley, Siemens en KKR actief om hun echte wereldse activa te ketenen. Ondertussen proberen sommige toonaangevende gedecentraliseerde financiële (DeFi) protocollen op het gebied van crypto, zoals MakerDAO en <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, passen constant hun strategieën aan om zich aan te passen aan en de trend van RWA te omarmen.</p>
<p>Tokenisatie van activa in de echte wereld (RWA) zet de eigenwaarde van tastbare of ontastbare activa (zoals eigendomsrechten, inkomstenrechten en gebruiksrechten) om in digitale tokens, waardoor directe opslag en overdracht van activa op de blockchain mogelijk is zonder traditionele tussenpersonen. Dit proces voorziet deze activa niet alleen van de unieke kenmerken van cryptocurrency, zoals decentralisatie, beveiliging en anonimiteit, maar brengt ook ongekende transactie-efficiëntie en transparantie met zich mee.</p>
<p>We hebben ontdekt dat in de huidige marktomstandigheden van zwakke volatiliteit, de RWA-sector een van de weinige sectoren is die een blijvende hitte en waarde-innovatiepotentieel heeft in vergelijking met de AI, MEME, DePIN en andere sectoren die in het verleden vaak besproken zijn. Volgens gegevens van CoinMarketCap zijn er op de schrijfdatum 142 projecten in de RWA-sector, waaronder Ondo (ONDO), MakerDAO (MKR), Polymesh (POLYX), enz., met een totale marktwaarde van meer dan $40B, wat slechts 0,16% vertegenwoordigt van de totale marktkapitalisatie van de cryptomarkt. Er is een groot potentieel voor opwaartse ontwikkeling.</p>
<p>Wat betreft zakelijke gegevens, volgens de gegevens van DeFiLlama is de RWA-markt nu de op één na grootste categorie in het DeFi-veld, met 14 RWA-protocollen en een totale waarde die de $4.1B overschrijdt.</p>
<p>Zoals te zien is op de onderstaande figuur, na de turbulente april en mei, herwon de door token gebaseerde Amerikaanse schatkistobligaties gedomineerde RWA-markt zijn opwaartse trend. Dit kan te maken hebben met het herstel van de algehele cryptomarkt en investeerders die verschuiven naar hogere opbrengsten in DeFi-leningen en de liquiditeit-herinzetmarkt.<br><img src="https://gimg2.gateimg.com/image/article/17182418202.jpeg" alt=""><br>Bron: DeFiLlama</p>
<h2 id="h2-Wat20zijn20de20innovatieve20hoogtepunten20van20de20RWA20Track208369"><a name="Wat zijn de innovatieve hoogtepunten van de RWA Track?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de innovatieve hoogtepunten van de RWA Track?</h2><p>RWA is geen eenvoudig getokeniseerd on-chain bedrijf van Amerikaanse schatkistobligaties. Volgens onze waarneming zijn er veel innovatieve hoogtepunten geweest in de ontwikkeling van deze sector.</p>
<h3 id="h3-120Digitalisering20van20activa20het20bereiken20van20naadloze20integratie20van20activawaarde502039"><a name="1. Digitalisering van activa: het bereiken van naadloze integratie van activawaarde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Digitalisering van activa: het bereiken van naadloze integratie van activawaarde</h3><p>De tokenisatie van RWA maakt de digitale representatie van de waarde van activa mogelijk, waardoor traditionele activa naadloos kunnen integreren in de digitale wereld. Deze innovatie maakt activa die oorspronkelijk moeilijk te verhandelen en te verhandelen waren, zoals onroerend goed, kunst, enz., gemakkelijker te verhandelen en te verhandelen.</p>
<p>Als voorbeeld van het nemen van het Sol on-chain vastgoed RWA-platform Parcl, kunnen huiseigenaren huurinkomsten van meerdere vastgoedprojecten onder hun hoede omzetten in digitale activa en transacties uitvoeren in het DeFi-ecosysteem via dit platform. Dit biedt beleggers meer diverse investeringsmogelijkheden en nieuwe financieringskanalen voor vastgoedontwikkelaars, met als doel maximale waarde van activa te bereiken.</p>
<h3 id="h3-220Gedecentraliseerde20handel20vermindering20van20transactiekosten20en20verbetering20van20transactieefficintie538493"><a name="2. Gedecentraliseerde handel: vermindering van transactiekosten en verbetering van transactie-efficiëntie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Gedecentraliseerde handel: vermindering van transactiekosten en verbetering van transactie-efficiëntie</h3><p>RWA-handel in het DeFi-ecosysteem zonder de betrokkenheid van traditionele financiële tussenpersonen, waardoor transactiekosten en risico’s worden verminderd. De automatische uitvoering van transactievoorwaarden via slimme contracten vermindert het risico op menselijke tussenkomst en foutieve handelingen.</p>
<p>Intussen hebben RWA-tokens of digitale activa professionele bewaring en handelsplatforms, vooral DePIN. Dit platform biedt een meer on-chain en inheemse oplossing voor het uitgeven en verankeren van RWA-activa, waardoor de veiligheid en efficiëntie van transacties worden gewaarborgd.</p>
<h3 id="h3-320Rijke20investeringsmogelijkheden20uitbreiding20van20de20reikwijdte20van20vermogensallocatie200315"><a name="3. Rijke investeringsmogelijkheden: uitbreiding van de reikwijdte van vermogensallocatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Rijke investeringsmogelijkheden: uitbreiding van de reikwijdte van vermogensallocatie</h3><p>Het is duidelijk dat in vergelijking met het verhaal dat beperkt is tot Initial Coin Offering / Security Token Offering (ICO/STO) in 2018, het RWA van vandaag bredere innovatieve voorwaarden, dekking en ontwikkelingspotentieel heeft.</p>
<p>De op tokens gebaseerde RWA stelt beleggers in staat om toegang te krijgen tot meer gediversifieerde activacategorieën, zoals onroerend goed, kunst, goud, schatkistpapier, enz. De tokenisatie van deze activa verrijkt niet alleen de beleggingskeuzes van beleggers, maar verbetert ook de efficiëntie van activaspreiding.</p>
<p>In het bijzonder hebben de Amerikaanse schatkistbon token activa, die momenteel het grootste aandeel van de RWA-markt innemen, niet alleen stabiele rendementen en lage risico’s, maar hebben ze ook een hoge liquiditeit en verhandelbaarheid. Beleggers kunnen op elk moment en overal deze schatkistbon tokens kopen en verkopen, waardoor de handige allocatie van wereldwijde activa wordt gerealiseerd.</p>
<p>Bijvoorbeeld breidt Galaxy Digital Holdings LP zijn uitleenbedrijf uit naar nieuwe klantengroepen. De laatste transactie is een miljoenenlening die is gedekt door een viool die ooit toebehoorde aan de Russische keizerin Catherine II. De viool zal worden bewaard door een bewaarder in Hong Kong, en het wegnemen ervan vereist zowel de hypotheekgever, Yat Siu, als Galaxy, om een overeenkomst te ondertekenen.<br><img src="https://gimg2.gateimg.com/image/article/17182418703.jpeg" alt=""><br>Bron: openbare informatie</p>
<h3 id="h3-420Slimme20contracten20zorgen20voor20de20automatisering20en20intelligentie20van20transacties546171"><a name="4. Slimme contracten: zorgen voor de automatisering en intelligentie van transacties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Slimme contracten: zorgen voor de automatisering en intelligentie van transacties</h3><p>De op blockchain gebaseerde smart contract technologie maakt RWA-transacties meer geautomatiseerd en intelligent. Smart contracts kunnen automatisch transactievoorwaarden uitvoeren, waardoor het risico op menselijke tussenkomst en foutieve handelingen wordt verminderd. Ondertussen kunnen smart contracts handelsstrategieën automatisch aanpassen op basis van marktomstandigheden, waardoor intelligente vermogensbeheer en optimalisatie worden bereikt.</p>
<p>Ondo Finance heeft bijvoorbeeld niet alleen traditionele ETF’s toegankelijk gemaakt op de blockchain door middel van een reeks innovatieve tokenisatiestrategieën, maar ook de handelsactiviteit van getokeniseerde aandelen gestimuleerd. Hun stap verkleint aanzienlijk de kloof tussen traditionele effecten en blockchain-technologie, waarbij de integratie tussen DeFi (decentralized finance) en traditionele financiën verder wordt benadrukt.</p>
<h2 id="h2-Risico20en20kans20bestaan20naast20elkaar20RWA20opent20biljoenen20dollars20aan20marktkapitaalruimte50965"><a name="Risico en kans bestaan naast elkaar, RWA opent biljoenen dollars aan marktkapitaalruimte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico en kans bestaan naast elkaar, RWA opent biljoenen dollars aan marktkapitaalruimte</h2><p>Als een belangrijk onderdeel van blockchain technologie en DeFi, laat het RWA track geleidelijk zijn unieke waarde en toepassingspotentieel zien.</p>
<p>Wereldwijde valuta- en marktgegevens tonen aan dat echte activa zoals zilver, goud, aandelen, wereldwijde obligaties, onroerend goed en derivaten een enorme marktomvang hebben, die ver uitstijgt boven de digitale valuta zelf. Door innovatieve methoden zoals activadigitalisering, gedecentraliseerde handel, diverse investeringskeuzes en slimme contracten, gaat de RWA-markt een gouden periode van snelle ontwikkeling in.</p>
<p>Volgens de Boston Consulting Group wordt verwacht dat de wereldwijde tokenisatiemarkt voor financiële activa tegen 2030 maar liefst $16 biljoen zal bereiken. Deze trend geeft niet alleen aan dat de brug tussen traditionele financiën (TradFi) en gedecentraliseerde financiën (DeFi) geleidelijk vorm begint te krijgen, maar legt ook een solide basis voor de creatie van de markt van de volgende generatie.<br><img src="https://gimg2.gateimg.com/image/article/17182418924.jpeg" alt=""><br>Bron: Boston Consulting Group</p>
<p>Op dit moment heeft de handel in activa zoals stablecoins en schatkistpapier on-chain de haalbaarheid van activatokenisatie aangetoond, en meer projecten onderzoeken actief de opname van meer soorten activa in het blockchain-veld.</p>
<p>De tokenisatie van RWA staat echter ook voor een reeks uitdagingen. Hoewel het tokeniseren van activa op ongelicenseerde openbare blockchains gebruik kan maken van on-chain liquiditeit, kan het vanwege zijn trustloze karakter te maken krijgen met strenge regelgevende controle, wat momenteel de meest dringende uitdaging is voor cryptotechnologie om praktische toepassingen te realiseren.</p>
<p>Hoewel getokeniseerde activa op privénetwerken en -ecoen aan regelgevende vereisten kunnen voldoen, kunnen ze beperkter zijn in het aantrekken van gebruikers en investeerders.</p>
<p>Bovendien blijft er een urgent probleem bestaan: hoe de vraag naar getokeniseerde activa te vergroten, hun liquiditeit en praktische bruikbaarheid te verbeteren, en de operationele ervaring, transactiekosten en technische risico’s in evenwicht te brengen.</p>
<p>Met de voortdurende vooruitgang van technologie en de verbetering van het regelgevingskader, wordt verwacht dat de RWA-markt nieuwe vitaliteit zal brengen in de innovatie en ontwikkeling van de wereldwijde financiële sector. Het is voorzien dat blockchain-transacties van meer realistische verhandelbare activa meer traceerbaar, transparant, efficiënt en veilig zullen worden, wat een nieuw tijdperk van vermogensbeheer en handel inluidt. We hebben reden om te geloven dat RWA de volgende opmerkelijke grens zal zijn in het veld van crypto.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>