RGFnZWxpamtzIG5pZXV3cyB8IEJOQi1rZXRlbiBNVUJBUkFLLW1hcmt0a2FwaXRhYWwgb3ZlcnNjaHJlZWQgJDIwMCBtaWxqb2VuLCBQTFVNRSBzdGVlZyBtZWVyIGRhbiAyMCUgaW4gw6nDqW4gZGFn

2025-03-18, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/174226886712.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20WLFI20heeft20SUI20en20ONDO20opgenomen20in20zijn20strategische20reserves20en20YZi20Labs20heeft20aangekondigd20te20investeren20in20Plume20Network841416"><a name="Crypto Dagelijkse Samenvatting: WLFI heeft SUI en ONDO opgenomen in zijn strategische reserves, en YZi Labs heeft aangekondigd te investeren in Plume Network" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: WLFI heeft SUI en ONDO opgenomen in zijn strategische reserves, en YZi Labs heeft aangekondigd te investeren in Plume Network</h2><p>Volgens gegevens van Farside Investors bedroeg de totale nettostroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs gisteren was $274 miljoen, waarvan BlackRock IBIT $42 miljoen ontving en Fidelity FBTC $127 miljoen ontving. Dit is de grootste enkelvoudige ETF instroom sinds 7 februari 2025.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had a totale uitstroom van $7.3 miljoen, waarvan Grayscale ETHE een uitstroom van $7.3 miljoen had, en BlackRock ETHA-gegevens zijn nog niet bijgewerkt. De ETH/BTC-wisselkoers staat momenteel op 0.023, wat nog steeds bijna op het laagste niveau in bijna 4 jaar is.</p>
<p><strong>YZi Labs heeft geïnvesteerd in Plume Network</strong></p>
<p>Gisteravond kondigde YZi Labs een investering aan in Plume Network, met als doel om tastbare activa on-chain te brengen en RWAfi te bevorderen. Plume bouwt een EVM-compatibele omgeving die niet alleen diverse RWAs kan introduceren, maar ze ook kan verbinden met een samenstelbaar RWAfi-ecosysteem om ze praktisch te maken.</p>
<p>Plume Network is het eerste modulaire RWAFi-blockchain op maat gemaakt voor RWAs. Het vereenvoudigt de manier waarop echte wereld activa on-chain zijn door naleving en activa tokenisatie rechtstreeks in de protocol laag in te bedden. Terwijl andere protocollen zich voornamelijk richten op financiële instrumenten, is de architectuur van Plume ontworpen om een breder scala aan activa te accommoderen, waaronder verzamelobjecten, grondstoffen en zelfs gegevensfeeds uit de echte wereld, wat nieuwe mogelijkheden opent voor gedecentraliseerde financiën (DeFi) en institutionele participatie.</p>
<p><strong>WLFI heeft aangekondigd dat het BTC, ETH, TRX heeft opgenomen, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, SUI, en ONDO in zijn strategische tokenreserves</strong></p>
<p>Volgens officieel nieuws heeft Trump’s crypto-project WLFI aangekondigd dat de voltooiing van een tokenverkoop van $550 miljoen is voltooid, met meer dan 85.000 deelnemers die KYC-certificering hebben voltooid.</p>
<p>WLFI ‘Macro Strategy’ wijst ook een verscheidenheid aan digitale activa toe in zijn strategische reserveplan, waaronder BTC, ETH, TRX, <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a>, SUI en ONDO-tokens. ‘Macro Strategy’ kan gedeeltelijk worden gebruikt om WLFI te ondersteunen bij het financieren van innovatieve projecten, het bevorderen van ecosysteemgroei en het creëren van nieuwe kansen in het snel ontwikkelende DeFi-veld.</p>
<p><strong>Lazard visie: De Fed wordt niet verwacht de rentetarieven te verlagen tot 2025</strong></p>
<p>Hoofdmarktstrateeg van Lazard, Temple, analyseerde dat vanwege inflatierisico’s Lazard nog steeds verwacht dat de Federal Reserve de rente niet zal verlagen in 2025. Hij zei dat de opvattingen van Lazard aanzienlijk verschillen van de marktconsensus, en de markt gelooft over het algemeen dat er dit jaar drie renteverlagingen kunnen zijn.</p>
<p>“Mijn standpunt verschilt van het consensusstandpunt omdat ik verwacht dat de Amerikaanse tarieven in omvang en omvang zullen toenemen, waardoor de inflatie tegen 2025 zal stijgen,” zei Temple. Een heropleving van de inflatie zou niet noodzakelijkerwijs leiden tot een renteverhoging, maar stijgende prijsdruk zou de Fed ervan kunnen weerhouden het beleid te versoepelen als de werkloosheid stijgt, zei hij.</p>
<h2 id="h2-Markttrends20MUBARAK20ging20online20en20steeg20meer20dan205020keer20PLUME20steeg202020in20n20dag416233"><a name="Markttrends: MUBARAK ging online en steeg meer dan 50 keer, PLUME steeg 20% in één dag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: MUBARAK ging online en steeg meer dan 50 keer, PLUME steeg 20% in één dag</h2><h3 id="h3-Markt20Hotspots684736"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain MUBARAK, CAKE, BNX, CHEEMS en andere tokens stegen allemaal, en <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a>-chain werd de best presterende publieke chain in het ecosysteemproject van de afgelopen tijd; Mubarak betekent zegen in het Arabisch, en de MUBARAK-token van dezelfde naam is een memeproject van BNB-chain. Sinds de lancering op 13 maart is de hoogste stijging meer dan 50 keer geweest. In deze periode ontving MUBARAK ook retweetondersteuning van CZ; de marktkapitalisatie van MUBARAK bereikte een maximum van $217 miljoen en staat momenteel op $190 miljoen, waarmee het op de 224e plaats staat op de gehele markt;</p>
<p>Het RWA-conceptproject Plume Network-token PLUME steeg met 20% op de dag, met een marktkapitalisatie van meer dan $350 miljoen; PLUME heeft gisteren aangekondigd dat het financiering heeft ontvangen van een toonaangevende investeringsinstelling, en het nieuws heeft een stijging in PLUME gestimuleerd; sinds PLUME eind januari op de beurs genoteerd stond, schommelde de prijs tussen $0,1 en $0,15, en brak momenteel door $0,18, wat in de toekomst mogelijk de moeite waard is om in de gaten te houden.</p>
<h3 id="h3-Gangbare20Munten235327"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC bevindt zich in een klein bereik van $82.500-$84.000. De markt kan meer fluctueren rond de rentevergadering van de Federal Reserve op donderdag. De AHR999-index van vandaag is 0,81, wat aangeeft dat het geschikt is voor langetermijnbeleggers om te investeren.</p>
<p>ETH heeft de afgelopen week minder volatiliteit gezien en is rond de $1.900 gebleven. De ETH/BTC-wisselkoers is bijna op het laagste niveau in 4 jaar gebleven.</p>
<p>Altcoins zagen gemengde winsten en verliezen, waarbij alleen projecten op de BNB-chain een algemene stijging zagen.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20sloten20hoger20en20de20Federal20Reserve20zal20naar20verwachting20de20rentetarieven20niet20verlagen20in20de20eerste20helft20van20het20jaar596518"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten hoger, en de Federal Reserve zal naar verwachting de rentetarieven niet verlagen in de eerste helft van het jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten hoger, en de Federal Reserve zal naar verwachting de rentetarieven niet verlagen in de eerste helft van het jaar</h2><p>De drie belangrijkste Amerikaanse aandelenindexen sloten hoger, met de S&amp;P 500 die met 0,64% steeg naar 5.675,12 punten, de Dow Jones met 0,85% steeg naar 41.841,63 punten en de Nasdaq met 0,31% steeg naar 17.808,66 punten. Het referentiepunt van de 10-jaars Treasury-rente bedroeg 4,31% en de 2-jaars Treasury-rente, die het gevoeligst is voor het rentetarief van de Fed, bedroeg 4,06%.</p>
<p>Marktanalyse toont aan dat de drie belangrijkste Amerikaanse aandelenindices momenteel oververkocht zijn op het hoogste niveau sinds 2022, marktsentiment en positiemarkers aanzienlijk zijn verbeterd, en seizoensfactoren eind maart naar verwachting zullen zorgen voor verbeterde winstherzieningen en aandelenkoersprestaties. Bovendien zou de recente verzwakking van de Amerikaanse dollar moeten helpen bij het resultaat van het eerste kwartaal en de prestatierichtlijnen voor het tweede kwartaal, wat gunstiger is dan het vierde kwartaal van 2024. Als historische patronen nog steeds van toepassing zijn, zou het dalen van de rente de kans op economische gegevens die de verwachtingen overtreffen kunnen vergroten.</p>
<p>Sommige mensen geloven dat de huidige Amerikaanse inflatie boven de 3% blijft, wat betekent dat de Fed niet vooraf rentetarieven kan verlagen in de eerste helft van het jaar, dus lagere obligatierendementen zullen een ‘automatische stabilisator’ worden voor economische groei. De Amerikaanse schatkistrendementcurve zal blijven afvlakken totdat de VS zijn schuldenplafond aanzienlijk verhoogt of de Fed gedwongen wordt tot grootschalige renteverlagingen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing T.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandige 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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>