WVppIExhYnMgZG9ldCBlZW4gc3RyYXRlZ2lzY2hlIGludmVzdGVyaW5nIGluIFBsdW1lIE5ldHdvcmsgb20gZGUgYWRvcHRpZSB2YW4gUldBIHRlIHZlcnNuZWxsZW4=

2025-03-19, 02:56

<p><img src="https://gimg2.gateimg.com/image/article/1742352904hot.webp" alt=""></p>
<p>In een belangrijke ontwikkeling voor de blockchain-industrie heeft YZi Labs (voorheen bekend als Binance Labs) aangekondigd dat zij een strategische investering doen in Plume Network, een modulair blockchaintplatform dat is ontworpen om traditionele financiën te verbinden met gedecentraliseerde financiën via Real World Assets (RWAs). De investering, onthuld op 17 maart 2025, markeert een belangrijke mijlpaal in het groeiende RWAfi (Real World Asset Finance) ecosysteem.</p>
<h2 id="h2-YZi20Labs20ondersteunt20de20visie20van20Plume20op20echte20wereld20activa203815"><a name="YZi Labs ondersteunt de visie van Plume op echte wereld activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>YZi Labs ondersteunt de visie van Plume op echte wereld activa</h2><p>YZi Labs’ Chief Investment Officer Max Coniglio benadrukte het strategische belang van deze investering en benadrukte het potentieel van Plume om de adoptie van real-world assets op blockchain technologie te revolutioneren.</p>
<p>“Bij YZi Labs investeren we in projecten die gebruikmaken van blockchaintechnologie om echte impact te creëren, en Plume is een prime voorbeeld - ze brengen echte wereldactiva naar de blockchain om nieuw kapitaal vrij te maken, bereik te vergroten en adoptie te stimuleren,” verklaarde Coniglio. “Door RWAs zo eenvoudig te maken als elk ander digitaal activum, overbrugt Plume traditionele financiën en DeFi, waardoor de weg wordt vrijgemaakt voor bredere adoptie.”</p>
<p>Deze investering komt op een cruciaal moment, nu de RWA-sector naar voren is gekomen als een van de snelstgroeiende segmenten in de cryptobranche. Volgens DefiLlama RWA-gegevens heeft de totale waarde die is vergrendeld (TVL) in RWAs recentelijk een recordhoogte van $9,9 miljard bereikt, waarbij de sector een stijging van 237,2% heeft doorgemaakt in het afgelopen jaar – aanzienlijk beter presterend dan veel andere cryptosectoren.</p>
<h2 id="h2-Wat20is20Plume20Network629988"><a name="Wat is Plume Network?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Plume Network?</h2><p>Plume Network is een volledig geïntegreerde, modulaire blockchain die speciaal is ontworpen voor de tokenisatie en integratie van real-world assets in het blockchain-ecosysteem. Het biedt een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine (EVM)-compatibele omgeving die het naadloos aan boord brengen van verschillende soorten activa mogelijk maakt, waaronder:</p>
<ul>
<li>Traditionele financiële instrumenten</li><li>Koolstofkredieten</li><li>GPU rekenbronnen</li><li>Digitale collecties en alternatieve investeringen</li></ul>
<p>Door zijn samenstelbaar ecosysteem stelt Plume gebruikers in staat om:</p>
<ul>
<li>Beloningen te verdienen door staking</li><li>Activa te verhandelen</li><li>Te lenen en uit te lenen</li><li>Diverse soorten activa uit te wisselen</li><li>Deel te nemen aan marktspeculatie</li></ul>
<p>Het platform heeft al aanzienlijke tractie aangetoond via zijn testnet-operatie, die 18 miljoen portefeuilles heeft aangetrokken en partnerschappen heeft gesloten met 180 protocollen in zijn netwerk.</p>
<h2 id="h2-Het20overbruggen20van20de20kloof20tussen20TradFi20en20DeFi261078"><a name="Het overbruggen van de kloof tussen TradFi en DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het overbruggen van de kloof tussen TradFi en DeFi</h2><p>Chris Yin, mede-oprichter en CEO van Plume, benadrukte dat het platform een kritische infrastructuurgat aanpakt dat al lang de brede acceptatie van RWAs in de cryptobranche heeft belemmerd.</p>
<p>“Terwijl de eerste stablecoin—RWA—met succes nieuwe gebruikers naar de cryptowereld heeft gebracht, worstelen andere RWA-activa nog steeds om dezelfde adoptie te bereiken,” legde Yin uit. “Met Plume kunnen activa-uitgevers van verschillende types nu worden <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> bouwers, die gemakkelijk verbinding maken met onze gemeenschap, ecosysteem en liquiditeit.</p>
<p>Deze toegankelijkheid is essentieel voor de waardepropositie van Plume. Door echte activa even gemakkelijk toegankelijk en te gebruiken te maken als traditionele cryptotokens, schept Plume mogelijkheden voor zowel crypto-inheemse gebruikers als traditionele financiële instellingen om deel te nemen aan de blockchain-economie.</p>
<h2 id="h2-Strategische20Partnerschappen20en20Toekomstige20Groei766736"><a name="Strategische Partnerschappen en Toekomstige Groei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Strategische Partnerschappen en Toekomstige Groei</h2><p>Plume Network heeft onlangs aangekondigd dat het een partnerschap is aangegaan met Superstate om de adoptie van getokeniseerde real-world assets uit te breiden, waardoor Plume de eerste multi-chain partner is voor de USTB en USCC fondsen van Superstate. Deze samenwerking biedt crypto-investeerders toegang tot rendementen op staatsobligaties, terwijl het gebruik maakt van de compliance-gerichte infrastructuur van Plume om institutionele investeerders aan te trekken.</p>
<p>Met de steun van YZi Labs is Plume van plan om zijn marktuitbreiding te versnellen, met name in opkomende markten, en zijn positie in de RWA-tokenisatieruimte te versterken. De investering zal Plume ondersteunen bij het helpen van verschillende industrieën bij het adopteren van blockchaintechnologie en toegang te krijgen tot de voordelen van gedecentraliseerde financiën (DeFi).</p>
<h2 id="h2-Marktomgeving20en20vooruitzichten962158"><a name="Marktomgeving en vooruitzichten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktomgeving en vooruitzichten</h2><p>Hoewel de RWA-sector een indrukwekkende jaarlijkse groei heeft laten zien, is het vermeldenswaard dat deze recentelijk een daling van 12,1% van maand tot heden heeft ervaren. Dit lijkt echter deel uit te maken van een bredere marktaanpassing in plaats van een specifiek probleem van RWA, aangezien <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) hebben ook verliezen geleden gedurende dezelfde periode.</p>
<p>Kijkend naar de toekomst, vertegenwoordigt de strategische samenwerking tussen YZi Labs en Plume Network een belangrijke stap voorwaarts in de ontwikkeling van blockchain-infrastructuur die traditionele financiering naadloos verbindt met gedecentraliseerde financiering. Naarmate er meer real-world assets worden getokeniseerd en geïntegreerd in het blockchain-ecosysteem, kunnen we een toename van liquiditeit, grotere financiële inclusie en nieuwe investeringsmogelijkheden verwachten.</p>
<h2 id="h2-Waar20te20handelen20in20Plume20PLUME20Token807352"><a name="Waar te handelen in Plume (PLUME) Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar te handelen in Plume (PLUME) Token?</h2><p>Voor degenen die geïnteresseerd zijn in de handel in PLUME, is het nu beschikbaar op Gate.io, waar gebruikers real-time prijsbewegingen, liquiditeit en markttrends kunnen volgen.</p>
<h2 id="h2-Laatste20Gedachten131996"><a name="Laatste Gedachten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste Gedachten</h2><p>Door het aanpakken van de infrastructuurkloof in RWA-adoptie positioneert Plume Network zichzelf aan de voorhoede van een transformerende beweging in de blockchain- en financiële industrie, met het potentieel om te herstructureren hoe we denken over en omgaan met activa in het digitale tijdperk.</p>
<hr>
<h2 id="h2-20Disclaimer371650"><a name="📌 Disclaimer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>📌 Disclaimer</h2><p>Dit artikel is uitsluitend bedoeld ter informatie en vormt geen beleggingsadvies. Cryptocurrency-markten, inclusief RWA-tokenisatie, zijn zeer volatiel en de prijzen kunnen aanzienlijk fluctueren als gevolg van marktomstandigheden, regelgevende veranderingen en technologische ontwikkelingen. Beleggers dienen hun eigen onderzoek te doen (DYOR) en hun risicotolerantie in overweging te nemen alvorens te investeren in digitale activa.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Xina Z. </strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie. 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 zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>