RGFnZWxpamtzIG5pZXV3cyB8IEJUQy12b2xhdGlsaXRlaXQgZGFhbGRlIHRlcnVnIG5hYXIgMiw2OCUgbmFkYXQgaGV0IHRhcmllZmJlbGVpZCB3YXMgZ2XDr21wbGVtZW50ZWVyZCwgRVRIIHRlc3R0ZSBvcG5pZXV3IGRlIHN0ZXVuIHZhbiAkMS43ODA=

2025-04-03, 03:10

<p><img src="https://gimg2.gateimg.com/image/article/17436495074.3.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20volatiliteit20daalde20weer20naar2026820Fidelity20lanceerde20een20pensioenplan20om20te20investeren20in20cryptocurrencies435861"><a name="Crypto Dagelijkse Samenvatting: Bitcoin volatiliteit daalde weer naar 2.68%, Fidelity lanceerde een “pensioenplan” om te investeren in cryptocurrencies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> volatiliteit daalde weer naar 2.68%, Fidelity lanceerde een “pensioenplan” om te investeren in cryptocurrencies</h2><p>Volgens gegevens van Farside Investors, de US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had a total net inflow of $334 miljoen gisteren, waarvan FBTC een nettostroom had van $118 miljoen en ARKB een nettostroom had van $130 miljoen. BlackRock-gegevens zijn nog niet bijgewerkt.</p>
<p>Op het moment van schrijven, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF zag gisteren uitstromen van $31 miljoen, die allemaal afkomstig waren van Grayscale ETHE. De gegevens van BlackRock zijn nog niet bijgewerkt.</p>
<p><strong>Fidelity heeft een ‘pensioenplan’ gelanceerd om te investeren in cryptocurrencies, met ondersteuning voor BTC, ETH en LTC</strong></p>
<p>Fidelity heeft een crypto IRA (pensioenplan) gelanceerd waarmee Amerikaanse volwassenen kunnen investeren in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a>. De activa worden aangehouden door Fidelity en opgeslagen in koude portefeuilles. Volgens de website van Fidelity zijn er geen kosten voor het crypto-IRA-product.</p>
<p><strong>Als Bitcoin doorbreekt $85,000, zal de intensiteit van de liquidatie van short orders 1.287 miljard bereiken</strong></p>
<p>Op 3 april, volgens Coinglass-gegevens, als Bitcoin herstelt en doorbreekt $85,000, zal de cumulatieve liquidatie-intensiteit van short orders van mainstream CEX 1.287 miljard bereiken.</p>
<p>Daarentegen, als Bitcoin onder de $82,000 zakt, zal de cumulatieve liquidatie-intensiteit van long orders van mainstream CEX 287 miljoen bereiken.</p>
<p><strong>De volatiliteit van Bitcoin is scherp gedaald en staat nu op 2,68%</strong></p>
<p>Na de invoering van het tariefbeleid daalde de volatiliteit van Bitcoin scherp, nu op 2,68%, terwijl de volatiliteit die eind maart werd waargenomen 3,47% was. Hoge Bitcoin-volatiliteit is meestal gerelateerd aan marktsentiment. De implementatie van het tariefbeleid ging gepaard met een scherpe daling van de volatiliteit van Bitcoin, wat zou kunnen betekenen dat de markt op het punt staat een smalle bandbreedte van schommelingen in te gaan en af te koelen.</p>
<p><strong>First Digital ontkende de beschuldiging van Justin Sun: de reserves van FDUSD zijn in orde</strong></p>
<p>First Digital Trust heeft aangekondigd dat de recente beschuldigingen van Justin Sun tegen First Digital Trust volledig onwaar zijn. Dit geschil heeft betrekking op TUSD en heeft niets te maken met FDUSD. First Digital is volledig solvent. Elke dollar die FDUSD ondersteunt, is volledig, veilig, betrouwbaar en wordt verantwoord door door de VS gesteunde schatkistobligaties. Tegelijkertijd werd aangekondigd dat er op X om 16.00 uur Hongkongse tijd op donderdag 3 april een AMA zal worden gehouden om het probleem te bespreken.</p>
<h2 id="h2-Markttrends20Cryptocurrencies20trokken20over20het20algemeen20terug20ETH20testte20opnieuw20het20ondersteuningsniveau20van201780344385"><a name="Markttrends: Cryptocurrencies trokken over het algemeen terug, ETH testte opnieuw het ondersteuningsniveau van $1.780" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Cryptocurrencies trokken over het algemeen terug, ETH testte opnieuw het ondersteuningsniveau van $1.780</h2><h3 id="h3-Markt20Hotspots936130"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>In de afgelopen 24 uur, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> steeg en daalde vervolgens als gevolg van het incident. Wereldwijd werden in totaal 165.685 mensen geliquideerd, met een totaal liquidatiebedrag van $497 miljoen. Zowel long- als shortposities werden geliquideerd, met een liquidatiebedrag van longposities van $267 miljoen en een liquidatiebedrag van shortposities van $230 miljoen.</p>
<p>Wat betreft financieringstarieven laten de huidige belangrijkste CEX- en DEX-financieringstarieven zien dat de cryptomarkt nog steeds in een bearish trend zit. Financieringstarieven zijn tarieven die zijn vastgesteld door cryptohandelplatforms om een balans te behouden tussen contractprijzen en onderliggende activaprijzen. Ze worden gebruikt om de kosten of voordelen aan te passen van handelaren die contracten aanhouden om contractprijzen dicht bij onderliggende activaprijzen te houden.</p>
<h3 id="h3-Gangbare20Munten839157"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>Met de invoering van Amerikaanse tarieven is het risicokapitaal sterk gedaald, en Bitcoin is gedaald van $88.000 naar ongeveer $82.000. Op het moment van schrijven is de prijs van Bitcoin hersteld tot $83.458, een daling van 1,7% in 24 uur, waarbij het traditionele aandelenrisico overtreft.</p>
<p>Ethereum volgde de markttrend, met de prijs die daalde van $1.950 naar $1.785. Het veerde op naar $1.823 op het moment van schrijven. De prijsrange van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> van 1750-1800 heeft meerdere dalingstests ondergaan, en $1.780 kan worden gebruikt als een belangrijk medium-langetermijnsteunniveau.</p>
<p>Altcoins vielen over het algemeen, met dalingen die over het algemeen groter waren dan die van blue-chip munten zoals Bitcoin en Ethereum. De slechtst presterende socialfi-sector van gisteren bleef de daling leiden (-4,3%), met TON dat 4,7% daalde en MASK dat 7,5% daalde.</p>
<h2 id="h2-Macro20nieuws20Tarieven20werden20boven20verwachting20gemplementeerd20en20Amerikaanse20aandelen20daalden20scherp20na20sluiting20van20de20markt646188"><a name="Macro nieuws: Tarieven werden boven verwachting geïmplementeerd, en Amerikaanse aandelen daalden scherp na sluiting van de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Tarieven werden boven verwachting geïmplementeerd, en Amerikaanse aandelen daalden scherp na sluiting van de markt</h2><p>Na sluiting van de Amerikaanse aandelenmarkt op woensdag 2 april ondertekende de Amerikaanse president Trump twee uitvoeringsbesluiten over zogenaamde ‘wederkerige tarieven’ in het Witte Huis, waarbij werd aangekondigd dat de Verenigde Staten een ‘minimumtarief van 10%’ zouden instellen voor zijn handelspartners, dat van kracht zou worden om 00:01 uur Eastern Time op 5 april. Tegelijkertijd zou een persoonlijk hoger ‘wederkerig tarief’ worden opgelegd aan de landen met de grootste handelstekorten van de VS, dat van kracht zou worden om 00:01 uur Eastern Time op 9 april.</p>
<p>Het tariefbeleid overtrof verre de verwachtingen. Amerikaanse aandelen kelderden nadat de markt gesloten was. Het verlies van Apple liep ooit op tot 7,58%, en Tesla daalde met meer dan 6%. Het rendement van de Amerikaanse 10-jaars schatkist daalde scherp naar ongeveer 4,1307%, bijna 10 basispunten lager dan het intraday hoogtepunt. De koper futures in New York werden de grondstof met de grootste daling, die op een gegeven moment met 4% daalde.</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>