RGFnZWxpamtzIG5pZXV3cyB8IEV0aGVyZXVtIFNwb3QgRVRGIHphZyBnZWR1cmVuZGUgMTIgb3BlZW52b2xnZW5kZSBkYWdlbiBuZXR0b3N0cm9tZW4sIFNvbmljIE5ldHdvcmsgVFZMIG92ZXJzY2hyZWVkICQ4NTAgbWlsam9lbg==

2025-03-21, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/174253123415.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Ethereum20spot20ETF20heeft20gedurende201220opeenvolgende20dagen20een20nettostroom20uitstroom20ondergaan20Sonic20Network20TVL20overtrof2085020miljoen608302"><a name="Crypto Dagelijkse Samenvatting: Ethereum spot ETF heeft gedurende 12 opeenvolgende dagen een nettostroom uitstroom ondergaan, Sonic Network TVL overtrof $850 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF heeft gedurende 12 opeenvolgende dagen een nettostroom uitstroom ondergaan, Sonic Network TVL overtrof $850 miljoen</h2><p>Op 21 maart, volgens de monitoringgegevens van Farside Investors, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF had gisteren een netto instroom van $165,7 miljoen, wat de vijfde opeenvolgende dag van netto instroom markeert. Daarvan had BlackRock IBIT een netto instroom van $172,1 miljoen, en FETH had een netto uitstroom van $3,5 miljoen.</p>
<p>Gisteren, de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had een nettostroom van $12.5 miljoen en heeft nu nettostromen ervaren gedurende 12 opeenvolgende dagen, waarvan BlackRock ETHA een nettostroom van $9 miljoen had.</p>
<p><strong>Sonic Networks TVL overschreed $850 miljoen</strong></p>
<p>Op 21 maart meldde Defillama dat de TVL van Sonic Network $854 miljoen bedroeg, een stijging van 83% in de afgelopen maand.</p>
<p>De top drie TVL DeFi-protocollen van het netwerk zijn momenteel: uitleenprotocol Silo Finance, liquiditeitsstakingprotocol Beets, en <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> V3.</p>
<p><strong>ETH-aandelen op CEX zijn gedaald tot een dieptepunt van 10 jaar</strong></p>
<p>Op 21 maart, volgens gegevens van <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> Volgens analysebureau Santiment hebben <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>-houders door de vele DeFi- en stakingopties op de markt de beschikbare voorraad op handelsplatforms nu verlaagd tot 8,97 miljoen, het laagste niveau in bijna 10 jaar (het vorige dieptepunt was in november 2015).</p>
<p><strong>Pump.fun kondigde de lancering van PumpSwap aan</strong></p>
<p>Op 21 maart meldde CoinDesk dat Pump.fun een token-swapdienst heeft gelanceerd op basis van het protocol-liquiditeitspool. De dienst, genaamd PumpSwap, plaatst het project in directe concurrentie met de geautomatiseerde marktmakers (AMM’s) in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem dat gespecialiseerd is in on-chain tokentransacties.</p>
<p><strong>De toespraak van de top van Trump heeft niet aangekondigd <a href="/price/view/new-cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">nieuwe crypto</a>-gerelateerde beleid</strong></p>
<p>Op 20 maart duurde de toespraak van de Amerikaanse president Trump op de 2025 Digital Asset Summit slechts ongeveer 2 minuten. Het waren allemaal formele opmerkingen zonder nieuwe inhoud. Het was niet zoals eerder gemeld door verslaggever Eleanor Terrett dat Trump zijn volgende crypto-beleid zou aankondigen op de US Digital Asset Summit. Afgaande op de live-uitzending van de top, was de live-uitzendingzaal gevuld met teleurgestelde opmerkingen van volgers.</p>
<h2 id="h2-Markttrends20Altcoins20trokken20over20het20algemeen20terug20ETH20daalde20onder202000788967"><a name="Markttrends: Altcoins trokken over het algemeen terug, ETH daalde onder $2.000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Altcoins trokken over het algemeen terug, ETH daalde onder $2.000</h2><h3 id="h3-Markt20Hotspots162614"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>BANANA brak door de $23 heen, met een stijging van 23,4% in 24 uur. Sinds het raken van een kortetermijnbodem van $10,2 op 11 maart, is de munt meer dan verdubbeld. De toekomstplannen van het Banana Gun-team omvatten tokenvernietiging, inkomstendeling en verdere implementatie van het bonussysteem, wat een positieve invloed kan hebben op de tokenprijs.</p>
<p>Beïnvloed door het nieuws dat L3 mogelijk aan de activa-lijst van mainstream beurzen wordt toegevoegd, steeg L3 in korte tijd met meer dan 20%, waarbij tijdelijk $0.06831 werd gerapporteerd.</p>
<h3 id="h3-Gangbare20Munten16319"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC zakte tijdens de sessie even onder de $84.000. Na een korte opleving, de markt’s <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> duurde niet lang en keerde gisteren terug naar een ‘paniek’ staat. Vanuit marktperspectief slaagde BTC er nog steeds niet in om een opwaartse trend te handhaven, en de mogelijkheid van aanhoudende daling op korte termijn is nog steeds relatief hoog.</p>
<p>ETH is onder de $2.000 grens gezakt. Gezien de ETF-gegevens is het vooruitzicht niet optimistisch.</p>
<p>Altcoins hebben nog steeds geen onafhankelijke markt, en de markt daalde over de hele linie. De SocialFi en CeFi sectoren zijn relatief sterk. Binnen deze sectoren steeg de SocialFi sector met 1,44% in 24 uur. Binnen de sector, <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> (TON) steeg met 2,14% als gevolg van factoren zoals grote financiering, en Galxe (GAL) steeg met 3,10%. De CeFi-sector steeg met 0,67%, en binnen de sector steeg Binance Coin ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>) steeg met 1.14%.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20bleven20dalen20na20een20opleving20de20kerninflatie20in20Japan20bereikte20de20snelste20groei62534"><a name="Macro nieuws: Amerikaanse aandelen bleven dalen na een opleving, de kerninflatie in Japan bereikte de snelste groei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen bleven dalen na een opleving, de kerninflatie in Japan bereikte de snelste groei</h2><p>De markt verwerkte de beslissing van de Fed en twijfelde of de Fed de rente scherp kon verlagen in het licht van mogelijk inflatoire handelstarieven, terwijl de opmerkingen van de president van de Europese Centrale Bank, Christine Lagarde, op het marktsentiment drukten. Lagarde zei dat Amerikaanse tarieven de economische groei in de regio zouden kunnen treffen, maar kon geen harde toezegging doen over rentetarieven. De opleving op de Amerikaanse aandelenmarkt duurde slechts één dag op de dag van de beslissing van de Fed, en alle drie belangrijke Amerikaanse aandelenindexen daalden gisteren.</p>
<p>De kerninflatie van Japan, exclusief verse voedingsmiddelen, steeg in februari met 3% op jaarbasis, tegen 3,2% in januari, maar de kerninflatie steeg met 2,6%, de snelste groei in bijna een jaar. Dit resultaat ondersteunt het argument voor de Bank of Japan om de rentetarieven geleidelijk te blijven verhogen. De markt verwacht nog steeds dat de Bank of Japan de rente in juni of juli opnieuw zal verhogen en het tempo van renteverhogingen ongeveer elke zes maanden zal handhaven.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Rooick Z. &amp;<a href="/price/amp-amp" target="_blank" class="blog_inner_link">amp</a>; 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 beleggingsaanbevelingen. 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 hertweeten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>