RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0b21hcmt0IHJhYWt0IHNsZWNodHN0ZSBrd2FydGFhbHByZXN0YXRpZSBpbiAzIGphYXIsIEFDVCBUb2tlbiBwbG90c2VsaW5nIGdlY3Jhc2h0IGVuIG1lZXIgZGFuIDYwJSBnZWRhYWxk

2025-04-02, 03:09

<p><img src="https://gimg2.gateimg.com/image/article/17435632094.2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Crypto20markt20boekte20slechtste20kwartaalprestatie20in20bijna20320jaar20financieringspercentage20bleef20bearish172967"><a name="Crypto Dagelijkse Samenvatting: Crypto markt boekte slechtste kwartaalprestatie in bijna 3 jaar, financieringspercentage bleef bearish" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Crypto markt boekte slechtste kwartaalprestatie in bijna 3 jaar, financieringspercentage bleef bearish</h2><p>Volgens de gegevens van Farside Investors, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had a total net outflow of $157 million yesterday, of which FBTC had a net outflow of $85.4 million and ARKB had a net outflow of $87.4 million. BlackRock data has not been updated yet.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF zag een uitstroom van $36 miljoen, waarvan ETHW een nettouitstroom had van $26 miljoen. De gegevens van BlackRock zijn nog niet bijgewerkt.</p>
<p><strong>Financieringstarieven van belangrijke beurzen tonen aan dat de markt nog steeds bearish is</strong></p>
<p>Op 2 april, volgens de gegevens van Coinglass, tonen de huidige belangrijkste CEX- en DEX-financieringspercentages aan dat de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> is nog steeds in een neerwaartse trend. Financieringstarieven zijn tarieven die door cryptohandelplatforms worden ingesteld om een balans te handhaven tussen contractprijzen en onderliggende activaprijzen. Ze worden gebruikt om de kosten of voordelen van handelaren die contracten aanhouden aan te passen om contractprijzen dicht bij de onderliggende activaprijzen te houden.</p>
<p><strong>Mening: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF kapitaalinstromen zijn moeilijk op te pikken</strong></p>
<p>Matrixport heeft vandaag een grafiek uitgebracht waarin staat dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s voor de tweede opeenvolgende maand netto uitstroom hebben gezien. Hoewel de instroom jaar tot nu toe positief blijft ($1,05 miljard), is dit cijfer voornamelijk te wijten aan een stijging van $5,3 miljard in januari. Fondsenstromen tonen aan dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s nog steeds sterk afhankelijk zijn van gunstige financieringstarieven en arbitragemogelijkheden in plaats van brede investeerdersbelangen. Gezien het feit dat de speculatieve sentiment van retailers in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> blijft laag, het is moeilijk voor Bitcoin ETF fondsinvesteringen om op korte termijn aanzienlijk te herstellen.</p>
<p><strong>Crypto Fear and Greed Index steeg naar 44</strong></p>
<p>Volgens de gegevens van Alternative.me is de cryptovrees- en hebzuchtindex vandaag gestegen naar 44 (de index was gisteren 34), en de markt bevindt zich nog steeds in een “paniektoestand.”</p>
<p><strong>Crypto markt beleefde zijn slechtste kwartaalprestatie in bijna drie jaar</strong></p>
<p>QCP heeft onlangs een marktanalyse uitgebracht waarin staat dat Bitcoin, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en de S&amp;P 500-index hebben zojuist hun slechtste kwartaalprestatie in drie jaar vastgelegd, en de marktwaarde van de cryptomarkt is sinds vrijdag met meer dan $160 miljard verdampt. De terugval van vrijdag was te wijten aan het verlopen van opties aan het einde van het kwartaal, actieve verkoop door handelaren en negatieve tarieven voor eeuwigdurende futures-fondsen. Tegelijkertijd waren de kerninflatiegegevens hoger dan verwacht en bleef de consumentenbesteding traag.</p>
<h2 id="h2-Markttrends20Bitcoin20en20Amerikaanse20aandelen20stegen20tegelijkertijd20en20ACTtokens20crashten20plotseling20en20daalden20met20meer20dan206081424"><a name="Markttrends: Bitcoin en Amerikaanse aandelen stegen tegelijkertijd, en ACT-tokens crashten plotseling en daalden met meer dan 60%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Bitcoin en Amerikaanse aandelen stegen tegelijkertijd, en ACT-tokens crashten plotseling en daalden met meer dan 60%</h2><h3 id="h3-Marktpunten987210"><a name="Marktpunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktpunten</h3><p>Gisteren crashte ACT plotseling met 60% en wordt momenteel genoteerd op $0.07169. De oorzaak kan verband houden met de aanpassing van de hefboomwerking van ACT-tokens door de beurs. Sommige marktmakers’ posities overschreden de limiet en werden direct gesloten tegen de marktprijs. Na de ineenstorting van de contractprijs ontstond er een enorme prijskloof met de spotprijs, en de spotprijs stortte ook in.</p>
<p>In de afgelopen 24 uur zijn wereldwijd in totaal 103.846 mensen geliquideerd, met een totaal liquidatiebedrag van $258 miljoen. De grootste enkele liquidatie vond plaats in ACT-tokens, met een enkel liquidatiebedrag van $3.788 miljoen.</p>
<h3 id="h3-Gangbare20Munten845527"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>Bitcoin werd beïnvloed door het stoppen van de val van de Amerikaanse aandelenmarkt en steeg lichtjes in sync met de Amerikaanse aandelenmarkt. Op het moment van schrijven werd Bitcoin genoteerd op $84,750, een stijging van 2.3% in 24 uur. De correlatiecoëfficiënt tussen Bitcoin en Amerikaanse aandelen is momenteel meer dan 0.6, met een duidelijke positieve correlatie.</p>
<p><a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> steeg in lijn met de bredere markt die dag, waarbij de prijs steeg tot wel $1,927. Op het moment van schrijven is er een aanzienlijke correctie geweest, waarbij de huidige prijs op $1,877 ligt, en alle winsten tijdens de handelssessie op de Amerikaanse beurs zijn nu teruggedraaid.</p>
<p>Altcoins volgden de opleving van de markt niet en waren ernstig verdeeld. De sectoren SocialFi (-4,1%) en NFT (-2,3%) leidden de daling, waarbij MASK-tokens in 24 uur met 33% daalden en PENGU-tokens met 9% daalden.</p>
<h2 id="h2-Macro20nieuws20de20Amerikaanse20ISM20manufacturing20PMI20kromp20voor20het20eerst20dit20jaar20de20huidige20olieprijzen20stabiliseerden377522"><a name="Macro nieuws: de Amerikaanse ISM manufacturing PMI kromp voor het eerst dit jaar, de huidige olieprijzen stabiliseerden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: de Amerikaanse ISM manufacturing PMI kromp voor het eerst dit jaar, de huidige olieprijzen stabiliseerden</h2><p>De Amerikaanse ISM-manufacturingsindex kromp voor het eerst dit jaar en de prijsindex bereikte een nieuw hoogtepunt sinds juni 2022. De Amerikaanse ISM-manufacturingsindex in maart was 49, wat lager was dan verwacht en voor het eerst dit jaar kromp. De prijsindex steeg scherp voor de tweede opeenvolgende maand en de fabrieksorders en werkgelegenheid waren beide traag, wat het effect van de tarieven van Trump op de Amerikaanse economie benadrukte.</p>
<p>Ruwe olieprijzen waren stabieler, met Brent op $74.47 per vat en Amerikaanse WTI op $71.21 per vat. De markt reageerde op zorgen over de impact van nieuwe Amerikaanse tarieven en een mogelijke handelsoorlog, evenals dreigingen van secundaire tarieven op Russische olie en verhoogde sancties tegen Iran.</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 visie van de onderzoeker en vormt geen enkele beleggingssuggestie. Alle beleggingen 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>