RGFnZWxpamtzIG5pZXV3cyB8IFNvbmljIFRWTCBvdmVyc2NocmVlZCAkMSBtaWxqYXJkLCBFVEgvQlRDIHdpc3NlbGtvZXJzIGJlcmVpa3RlIGVlbiBuaWV1dyBkaWVwdGVwdW50IGluIGJpam5hIDQgamFhcg==

2025-03-12, 02:46

<p><img src="https://gimg2.gateimg.com/image/article/17417473128.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Meerdere20Crypto20Spot20ETFgoedkeuringen20vertraagd20Sonic20TVL20overschreed20120miljard265222"><a name="Crypto Dagelijkse Samenvatting: Meerdere Crypto Spot ETF-goedkeuringen vertraagd, Sonic TVL overschreed $1 miljard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Meerdere Crypto Spot ETF-goedkeuringen vertraagd, Sonic TVL overschreed $1 miljard</h2><p>Op 12 maart, volgens gegevens van Farside Investors, de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had een nettostroom van $367.44 miljoen gisteren, waarvan BlackRock IBIT een nettostroom had van $147.74 miljoen, Invesco BTCO een nettostroom had van $33.7 miljoen, en Grayscale GBTC een nettostroom had van $35.5 miljoen.</p>
<p>Gisteren, de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had een netto uitstroom van $21,36 miljoen, waarvan BlackRock ETHA een netto uitstroom had van $11,56 miljoen en Fidelity FETH een netto uitstroom had van $9,8 miljoen.</p>
<p><strong>Sonic TVL overschreed $1 miljard</strong></p>
<p>Op 12 maart heeft Sonic’s totale waarde opgesloten (TVL) volgens de gegevens van DefiLlama $1 miljard overschreden en is $1,086 miljard bereikt. Deze gegevens zijn opgenomen in de beloningen/liquiditeit van uitgeleende activa en gestorte activa in de uitleenovereenkomst.</p>
<p>Uitgebreid lezen: <a href="https://www.gate.io/blog/6211/Shadow-and-Sonic--A-Mutual-Success" target="_blank">Shadow en Sonic: Een Gezamenlijk Succes</a></p>
<p><strong>Mening: Het uitstel van de Fed om de rente te verlagen tot 2025 kan een berenmarkt veroorzaken</strong></p>
<p>Timothy Peterson, een online econoom, waarschuwde dat als de Federal Reserve renteverlagingen in 2025 uitstelt, dit zou kunnen leiden tot een bredere marktdaling en <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> terug zou kunnen slepen naar $70.000. Volgens zijn analysemodel zou <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> kunnen dalen tot $57.000 in de volgende berenmarkt, maar hij zei dat dit onwaarschijnlijk is omdat te veel beleggers ‘Bitcoin als gieren in de gaten houden’.</p>
<p>Uitgebreid lezen: <a href="https://www.gate.io/blog/6427/Is-the-Crypto-Market-in-a-Bear-Phase---Market-Analysis-and-Investment-Strategies" target="_blank">Is de Crypto Markt in een Bear Fase? Marktanalyse &amp; Investeringsstrategieën</a></p>
<p><strong>Het aantal Monad-testnetadressen heeft 8,4 miljoen overschreden</strong></p>
<p>Op 12 maart, volgens on-chain gegevens, overschreed het aantal dagelijkse transacties op het Monad-testnet 22,62 miljoen, en het totale aantal transacties overschreed 270 miljoen. In de afgelopen 7 dagen zijn 2.907.775 nieuwe adressen toegevoegd, en het totale aantal testnet adressen is 8,4 miljoen.</p>
<p>Uitgebreid lezen: <a href="https://www.gate.io/blog/6259/Monad-Testnet-Breaks-100-Million-Transactions--The-Rise-of-a-High-Performance-Monad-Crypto-Blockchain" target="_blank">Monad Testnet doorbreekt 100 miljoen transacties: De opkomst van een high-performance Monad Crypto Blockchain</a></p>
<p><strong>SEC heeft de goedkeuring van meerdere crypto spot ETF’s uitgesteld</strong></p>
<p>Op 12 maart heeft de Amerikaanse Securities and Exchange Commission (SEC) vanochtend verschillende aanvragen voor crypto spot ETF’s uitgesteld, waaronder Grayscale <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>(ADA) en DOGE spot ETF’s, Canary’s <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> spot ETF’s en VanEck <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> spot ETF.</p>
<h2 id="h2-Markttrends20Bitcoin20herstelde20met20meer20dan20820ETHBTC20bereikte20een20nieuw20dieptepunt20in20bijna20420jaar627462"><a name="Markttrends: Bitcoin herstelde met meer dan 8%, ETH/BTC bereikte een nieuw dieptepunt in bijna 4 jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Bitcoin herstelde met meer dan 8%, ETH/BTC bereikte een nieuw dieptepunt in bijna 4 jaar</h2><h3 id="h3-Markt20Hotspots56387"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De totale marktkapitalisatie van cryptocurrencies veerde iets op tot $2,77 biljoen, een stijging van 2,5% in 24 uur. Sommige altcoins veerden als eerste op, waarbij BANANA nu wordt verhandeld op $16,59, een stijging van 57,66% in 24 uur, en AUCTION nu wordt verhandeld op $26,12, een stijging van 40,34% in 24 uur.</p>
<p>In de afgelopen 24 uur hebben wereldwijd in totaal 105.504 mensen hun posities geliquideerd, met een totaal liquidatiebedrag van $386 miljoen, inclusief zowel long- als shortposities, waarvan het totale liquidatiebedrag van shortposities $257 miljoen was.</p>
<h3 id="h3-Gangbare20Munten309924"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>Na onder de $80.000 te zijn gezakt, herstelde Bitcoin zwak. Op het moment van schrijven werd het genoteerd op $83.209, meer dan 8% hoger dan het dieptepunt van $76.606. In deze daling was Bitcoin relatief veerkrachtig, wat resulteerde in een stijging van zijn marktkapitalisatieaandeel van 56% aan het begin van het jaar tot 61%.</p>
<p><a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> herstelde samen met de markt en staat momenteel geprijsd op $1.920, meer dan 9,4% hoger dan het dieptepunt van $1.754. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> werd sterk beïnvloed door deleveraging op de markt in deze ronde van daling. De huidige ETH/BTC wisselkoers is 0,023, een nieuw dieptepunt in bijna vier jaar.</p>
<p>Altcoins zijn over het algemeen hersteld en komen uit een zwak herstel. <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a>-tokens in de grote-cap sector leidden de winsten, met een stijging van 10% in 24 uur en momenteel geprijsd op $2,2233. TRX staat momenteel geprijsd op $0,2252, een daling van 1,27% in 24 uur, en is de enige token in de grote-cap sector die niet is gestegen.</p>
<h2 id="h2-Macro20nieuws20Tariefbeleid20schommelt20en20internationale20goudprijzen20blijven20stabiel194602"><a name="Macro nieuws: Tariefbeleid schommelt en internationale goudprijzen blijven stabiel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Tariefbeleid schommelt en internationale goudprijzen blijven stabiel</h2><p>De bredere S&amp;P 500 steeg kort in de vroege handel na de scherpe daling van dinsdag voordat Trump nieuwe tarieven aankondigde als reactie op de stap van de Ontarische premier Ford om een toeslag van 25 procent op elektriciteit die naar de VS wordt verzonden op te leggen. De drie belangrijkste Amerikaanse aandelenindexen werden negatief, de Canadese dollar kelderde en de Amerikaanse staal- en aluminiumaandelen stegen. Bij het sluiten stond de S&amp;P 500-index 0,76% lager, de Dow Jones Industrial Average sloot 1,14% lager en de Nasdaq sloot 0,18% lager.</p>
<p>Goudprijzen bleven stabiel te midden van onzekerheid over tarieven en economische zorgen, bijna $2.915 per ounce houdend, terwijl investeerders reageerden op de herhaalde veranderingen in tarieven op Canadese staal- en aluminiumproducten door president Trump. Ondanks Trump die recessievrees en een zwakkere dollar bagatelliseerde, blijven markten op hun hoede voor mogelijke stagflatie-risico’s als gevolg van zwakke economische rapporten uit de VS.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Rooick Z.</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; 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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>