RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBibGVlZiBmbHVjdHVlcmVuLCBFVEggRVRGIGhlZWZ0IGdlZHVyZW5kZSAxMyBvcGVlbnZvbGdlbmRlIGRhZ2VuIG5ldHRvIHVpdHN0cm9vbSBlcnZhcmVu

2025-03-24, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/174278747316.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20IMF20included20Bitcoin20in20wereldwijde20economische20statistieken20standaarden20en20SUI20OP20en20andere20tokens20zullen20deze20week20in20grote20hoeveelheden20worden20vrijgegeven605785"><a name="Crypto Daily Digest: IMF included Bitcoin in wereldwijde economische statistieken standaarden, en SUI, OP en andere tokens zullen deze week in grote hoeveelheden worden vrijgegeven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: IMF included <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in wereldwijde economische statistieken standaarden, en SUI, OP en andere tokens zullen deze week in grote hoeveelheden worden vrijgegeven</h2><p>Volgens gegevens van Farside Investors, U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs hadden afgelopen vrijdag een totale netto instroom van $83.1 miljoen, waarvan BlackRock IBIT een instroom had van $105 miljoen en WTree BTCW een uitstroom had van $21.9 miljoen.</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETFs zagen afgelopen vrijdag een totale uitstroom van $18,6 miljoen, waaronder $11,9 miljoen van BlackRock ETHA en $6,7 miljoen van Grayscale ETH.</p>
<p><strong>SUI, OP, VENOM en andere tokens zullen deze week in grote hoeveelheden worden vrijgegeven</strong></p>
<p>Volgens de gegevens van Token Unlocks zullen deze week SUI, OP en VENOM eenmalig een grootschalige token unlock hebben, met een totale waarde van meer dan $100 miljoen. Daarvan zal Sui (SUI) 64,19 miljoen tokens ontgrendelen om 8:00 uur op 1 april, ter waarde van ongeveer $148 miljoen, goed voor 2,03% van de omloop. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> (OP) zal 31,34 miljoen tokens ontgrendelen om 8:00 op 31 maart, ter waarde van ongeveer $27,09 miljoen, wat overeenkomt met 1,93% van de omloop; Venom (VENOM) zal 59,26 miljoen tokens ontgrendelen om 16:00 op 25 maart, ter waarde van ongeveer $7,04 miljoen, wat overeenkomt met 2,9% van de omloop.</p>
<p><strong>IMF heeft <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en andere digitale activa opgenomen in de wereldwijde economische statistische normen</strong></p>
<p>In de zojuist uitgebrachte zevende editie van het Handboek voor de Betalingsbalans en de Internationale Investeringspositie (BPM7) heeft het Internationaal Monetair Fonds (IMF) gedetailleerde richtlijnen opgesteld over hoe crypto-activa zoals Bitcoin, stablecoins en op tokens gebaseerde platforms zoals <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> moeten worden geclassificeerd en geregistreerd. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>. Volgens het nieuwe kader worden digitale activa verdeeld in vervangbare tokens en niet-vervangbare tokens, en verder geclassificeerd op basis van al dan niet ze bijbehorende verplichtingen hebben. Bitcoin en andere tokens die niet gedekt zijn door verplichtingen worden beschouwd als niet-productieve niet-financiële activa en worden geclassificeerd op de kapitaalrekening.</p>
<p><strong>BlackRock CEO: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> wordt verwacht te stijgen naar $500,000 tot $700,000</strong></p>
<p>Volgens Cointelegraph verklaarde BlackRock CEO Larry Fink dat de prijs van Bitcoin naar verwachting zal stijgen tot $500.000 tot $700.000.</p>
<h2 id="h2-Markttrends20BTC20bleef20fluctueren20MUBARAK20presteerde20actief345317"><a name="Markttrends: BTC bleef fluctueren, MUBARAK presteerde actief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bleef fluctueren, MUBARAK presteerde actief</h2><h3 id="h3-Markt20Hotspots344660"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Een paar dagen geleden plaatste Trump op de sociale media Truth Social, zeggende: “Ik hou van $TRUMP, erg cool, geweldig team.” Beïnvloed door dit nieuws brak $TRUMP door $12 tijdens de sessie, met een stijging van meer dan 10% in 24 uur;</p>
<p>MUBARAK steeg in het weekend met 50%, wat hielp de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain sentiment om te herstellen. Sommige analisten wezen er echter op dat hoewel de hype rond Mubarak het sentiment op de <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain deed oplaaien, onder de huidige marktomstandigheden de duurzaamheid van de gekte nog moet worden getest als deze uitsluitend wordt gedreven door de emoties van oppakken en het maken van memes.</p>
<h3 id="h3-Gangbare20Munten373985"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC bleef schommelen, bereikte een keer $86,000, en daalde vervolgens naar het bereik van $85,000. Aangezien het vorige BTC-patroon is doorbroken, hoewel er een kortetermijnherstel is, vanuit het perspectief van het patroon, heeft het de neerwaartse trend nog niet volledig omgekeerd;</p>
<p>ETH is afgelopen vrijdag onder de $2.000 gezakt en heeft nog geen tekenen van een opwaartse beweging gezien. ETF’s hebben gedurende 13 opeenvolgende dagen netto uitstroom gezien, wat suggereert dat het in de toekomst zou kunnen blijven dalen;</p>
<p>De Altcoin-markt heeft een zwakke momentum, met gemengde winsten en verliezen. De AI ​​en PayFi sectoren hebben de winsten geleid, maar de markt als geheel ontbreekt een aantrekkelijk verhaal.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20beindigen20420weken20van20verliesreeks20marktonzekerheidsrisicos20werden20verminderd3447"><a name="Macro Nieuws: Amerikaanse aandelen beëindigen 4 weken van verliesreeks, marktonzekerheidsrisico’s werden verminderd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen beëindigen 4 weken van verliesreeks, marktonzekerheidsrisico’s werden verminderd</h2><p>Afgelopen vrijdag sloten de drie belangrijkste Amerikaanse aandelenindexen over het algemeen hoger, waarbij de S&amp;P 500 en Nasdaq vier opeenvolgende weken van dalingen afsloot.</p>
<p>Marktonzekerheid wordt ook verwacht verder te verminderen, aangezien verwacht wordt dat de Verenigde Staten op 2 april wederkerige tarieven zullen aankondigen, en de markt verwacht over het algemeen dat dit mogelijk nieuwe maatregelen tegen China kan omvatten. Sinds zijn aantreden in januari heeft Trump een 20% tarief op goederen uit China opgelegd. Gezien echter dat de Verenigde Staten niet willen dat de inflatie opnieuw stijgt, lijkt de vooruitzicht voor de handel tussen de VS en China optimistisch.</p>
<p>Morgan Stanley’s chief fixed-income strategist Vishwanath Tirupattur zei vrijdag dat de voorspelling van de bank voor het rendement op 10-jarige schatkistpapier aan het einde van het jaar 4% is, maar druk van tarieven kan het lager duwen. Aangezien de rendementen op Amerikaanse schatkistpapier positief gecorreleerd zijn met het marktgeïmpliceerde dieptepunt van de beleidsrente van de Federal Reserve, gelooft de markt momenteel dat met de officiële invoering van Amerikaanse tarieven op 2 april, het rendement op 10-jarige Amerikaanse schatkistpapier in de toekomst zal dalen, gedreven door factoren zoals Amerikaanse schuld- en tekortproblemen, zwakke economische gegevens, een eenmalige stijging van de inflatie als gevolg van tarieven, en het uitstel van de Federal Reserve bij de vermindering van de balans.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Orisi T.</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 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 zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>