RGFnZWxpamtzIG5pZXV3cyB8IFBJIENvaW4gYmVyZWlrdGUgZWVuIGhvb2d0ZXB1bnQgdmFuICQzIGVuIHRyb2sgdG9lbiB0ZXJ1ZywgaGV0IG1hcmt0YWFuZGVlbCB2YW4gRVRIIGRhYWxkZSB2b29yIGhldCBlZXJzdCBpbiA0IGphYXIgdG90IG9uZGVyIDEwJQ==

2025-02-28, 04:23

<p><img src="https://gimg2.gateimg.com/image/article/174071649920.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20heeft20gedurende20820opeenvolgende20dagen20nettostromen20ervaren20terwijl20ETH20en20SOL20meer20dan205020zijn20gedaald20vanaf20hun20historische20hoogtepunten760625"><a name="Crypto Dagelijkse Samenvatting: BTC ETF heeft gedurende 8 opeenvolgende dagen nettostromen ervaren, terwijl ETH en SOL meer dan 50% zijn gedaald vanaf hun historische hoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF heeft gedurende 8 opeenvolgende dagen nettostromen ervaren, terwijl ETH en SOL meer dan 50% zijn gedaald vanaf hun historische hoogtepunten</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 net outflow of $266 million yesterday, of which BlackRock had an outflow of $192 million and Fidelity FBTC had an outflow of $7.25 million. The BTC ETF has had a net outflow for eight consecutive days, with a total outflow of more than $3.2 billion in these eight days.</p>
<p>Gisteren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot-ETF’s zagen een uitstroom van $ 46,4 miljoen, waarvan BlackRock ETHA een uitstroom van $ 26,74 miljoen zag en Grayscale ETHE een uitstroom van $ 19,6 miljoen.</p>
<p><strong>Gegevens: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> daalde met 25% vanaf zijn all-time high, en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> daalde met meer dan 50% vanaf zijn all-time high</strong></p>
<p>Volgens marktgegevens van Gate.io is <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in 39 dagen met meer dan 25% gedaald ten opzichte van het historische hoogtepunt van $ 109.588 en wordt het nu verhandeld tegen $ 80.610. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is in 74 dagen met 55% gedaald ten opzichte van het hoogste punt in de bullmarkt van $ 4.107 en wordt nu verhandeld op $ 2.116; SOL is in 40 dagen met 55% gedaald ten opzichte van het historische hoogtepunt van $ 295,8 en wordt nu verhandeld tegen $ 129,6.</p>
<p><strong>Glassnode: Bitcoin kostconcentratiegebied van $96.000 tot $98.000 kan een sterk weerstandsniveau zijn</strong></p>
<p>Glassnode plaatste op sociale media dat “Tussen eind december 2024 en februari 2025 was er een sterke accumulatie in het $96.000 tot $98.000 gebied.”</p>
<p>Hoewel sommige adressen binnen deze prijsklassen hun BTC opnieuw toewijzen, blijft dit aanbodcluster extreem dicht - en zou het als sterke weerstand kunnen dienen als we dit niveau opnieuw bezoeken.”</p>
<p><strong>Analyse: Handhaaf een bullish standpunt, verwacht dat de markt voor het einde van de week zal herstellen</strong></p>
<p>“De aankondiging van de Amerikaanse president Donald Trump van een mogelijke 25% tarief op Europese goederen heeft beleggersangsten opnieuw aangewakkerd, waardoor de Crypto Fear &amp; Greed Index is gedaald naar 10, in het gebied van extreme angst,” zei Valentin Fournier, een analist bij BRN.</p>
<p>Hoewel sommigen bang zijn voor het begin van een bearmarkt, leert de geschiedenis dat terugval van 25% gebruikelijk is in bull-cycli, en de Amerikaanse inspanning om een nationale cryptoreserve op te bouwen blijft een belangrijke katalysator op de lange termijn. We handhaven onze bullish houding en verwachten dat de markt tegen het einde van de week zal herstellen. We blijven overgewicht hebben <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en blijf neutraal over BTC en ETH.</p>
<h2 id="h2-Markttrends20PImunt20bereikte20de2020320en20ervoer20een20terugval20het20marktaandeel20van20ETH20daalde20tot20onder20de2010558044"><a name="Markttrends: PI-munt bereikte de $ 3 en ervoer een terugval, het marktaandeel van ETH daalde tot onder de 10%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: PI-munt bereikte de $ 3 en ervoer een terugval, het marktaandeel van ETH daalde tot onder de 10%</h2><h3 id="h3-Markt20Hotspots818106"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De nieuwe munt van het AI-concept SHELL schoot omhoog, met de hoogste intraday-stijging van meer dan 40% op een gegeven moment; SHELL is het toonaangevende AI Agent-project dat wordt gepromoot door de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> keten. Met CZ die de <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a>-keten pusht, heeft SHELL veel steun gekregen; De huidige circulerende marktkapitalisatie van SHELL is $160 miljoen, wat 260e is op de hele markt, met een totale circulerende marktkapitalisatie van $600 miljoen;</p>
<p>PI-munt heeft een correctie ondergaan, waarbij een grote verkoop plaatsvond op het gehele getal van $3, en consolideert momenteel rond $2,5; De huidige circulerende marktkapitalisatie van PI is $17,7 miljard, en het daadwerkelijke circulatieniveau is slechts 6,7%; De volledige circulerende marktkapitalisatie van PI-munt is maar liefst $250 miljard, wat oneindig dicht bij de volledige circulerende marktkapitalisatie van ETH ligt; vanuit het oogpunt van marktkapruimte is deze prijsprestatie van PI-munt bijna onhoudbaar.</p>
<h3 id="h3-Mainstream20Munten75870"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC kelderde vandaag opnieuw en de BTC ETF had 8 opeenvolgende dagen een netto-uitstroom. Deze week werd een eendaags uitstroomrecord van meer dan $ 1,1 miljard geregistreerd. De volatiele neerwaartse trend op korte termijn zal zich voortzetten; de AHR999-index daalde onlangs ook sterk, wat aangeeft dat de huidige <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC prijs</a> is geschikt voor langetermijnbeleggers om regelmatig te investeren;</p>
<p>ETH is 5 opeenvolgende dagen gedaald en heeft de grens van $ 2.200 bereikt. Aan de financieringskant heeft ETH ETF deze week geen grote sell-off meegemaakt en volgt het nog steeds voornamelijk de markttrend. Tegelijkertijd daalde de ETHD vandaag officieel onder de 10% en staat nu op 9,8%, wat ook een nieuw dieptepunt is in de afgelopen 4 jaar;</p>
<p>Altcoins daalden over het algemeen en de markt ontbrak het aan een gezamenlijke narratieve hotspot.</p>
<h2 id="h2-Macro20News20Amerikaanse20aandelen20daalden20scherp20de20markt20kijkt20vanavond20naar20PCEgegevens812665"><a name="Macro News: Amerikaanse aandelen daalden scherp, de markt kijkt vanavond naar PCE-gegevens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Amerikaanse aandelen daalden scherp, de markt kijkt vanavond naar PCE-gegevens</h2><p>De drie belangrijkste Amerikaanse aandelenindexen daalden allemaal scherp, waarbij de S&amp;P 500 met 1,59% daalde tot 5.861,57 punten, de Nasdaq Composite met 2,78% daalde tot 18.544,42 punten en de Dow Jones Industrial Average met 0,45% daalde tot 43.239,5 punten. Het benchmarkrendement op 10-jaars Treasuries bedroeg 4,22% en het rendement op 2-jaars Treasuries, dat het meest gevoelig is voor de beleidsrente van de Fed, bedroeg 4,02%.</p>
<p>Qua macro-economische gegevens heeft een aantal gegevens die op de 27e zijn vrijgegeven ook de Amerikaanse aandelenmarkt verstoord. Daaronder toonde het rapport dat vrijgegeven werd door het Bureau of Economic Analysis in de VS aan dat het geannualiseerde kwartaal-op-kwartaal groeipercentage van het reële BBP in het vierde kwartaal van de Verenigde Staten werd herzien naar 2,3%, wat in lijn was met de marktverwachtingen en hetzelfde als de oorspronkelijke waarde. Hoewel het groeipercentage is vertraagd in vergelijking met eerdere kwartalen, toont het nog steeds de veerkracht van de Amerikaanse economie. De inflatiegegevens zijn echter niet optimistisch.</p>
<p>De markt houdt momenteel nauwlettend in de gaten naar het U.S. PCE-rapport voor januari 2025, dat om 21:30 vanavond Beijing-tijd zal worden vrijgegeven. Deze gegevens zullen de markt voorzien van de nieuwste aanwijzingen over de trend van de Amerikaanse inflatie en kunnen een belangrijke invloed hebben op de beleidsbeslissingen van de Federal Reserve.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing 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 enkele beleggingssuggestie. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Het opnieuw plaatsen van het artikel is toegestaan, op voorwaarde dat er naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>