RGFnZWxpamtzIG5pZXV3cyB8IFBJIENvaW4gQ2lyY3VsYXRpZSBNYXJrdHdhYXJkZSBvdmVyc2NocmVlZCAkMTAgbWlsamFyZCwgUldBIFRyYWNrIE9NIFRva2VuIGJlcmVpa3RlIGVlbiBuaWV1dyByZWNvcmRob29ndGU=

2025-02-24, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/174036881816.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20omzet20van20Pumpfun20daalde20met20bijna209020Strategy20kan20opnieuw20haar20BTCposities20verhogen543656"><a name="Crypto Dagelijks Overzicht: De omzet van Pump.fun daalde met bijna 90%, Strategy kan opnieuw haar BTC-posities verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De omzet van Pump.fun daalde met bijna 90%, Strategy kan opnieuw haar BTC-posities verhogen</h2><p>Volgens de gegevens van Farside Investors, de V.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had a netto uitstroom van $62.9 miljoen afgelopen vrijdag, en de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had een uitstroom van $8.9 miljoen. Sinds 2025 zijn de instromen van de twee ETF’s, BTC en ETH, week na week vertraagd, en vorige week hebben ze wekelijkse uitstroom ervaren, wat aangeeft dat het marktvooruitzicht zwak is vanuit een financieringsperspectief.</p>
<p><strong>De protocolvergoeding van pump.fun daalde met meer dan 88% vanaf zijn historische hoogtepunt</strong></p>
<p>Volgens de gegevens van DefiLlama bedroeg de protocolkosten van pump.fun afgelopen zaterdag $1,75 miljoen, een daling van 88,62% ten opzichte van het historische hoogtepunt ($15,38 miljoen op 25 januari). Het transactievolume van pump.fun afgelopen zaterdag was $137,25 miljoen, een daling van 64,83% ten opzichte van het historische hoogtepunt ($390,3 miljoen op 24 januari).</p>
<p>Daarnaast test pump.fun momenteel volgens de relevante pagina de swapfunctie intern. De gemeenschap speculeert dat het zijn eigen swapplatform zou kunnen lanceren om Raydium te vervangen.</p>
<p><strong>Michael Saylor heeft opnieuw een investeringstrackinggrafiek uitgebracht, waaruit een voortdurende stijging blijkt in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bezittingen</strong></p>
<p>Michael Saylor, oprichter van Strategy (voorheen MicroStrategy), heeft opnieuw een investeringstrackingdiagram uitgebracht, waaruit blijkt dat hij zijn bezit van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zal blijven vergroten. Vandaag zei hij: “Ik denk niet dat dit weerspiegelt wat ik vorige week heb gedaan.”</p>
<p>De portefeuille volggrafiek van MicroStrategy gebruikt een blauwe lijn om de prijstrend van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> aan te geven, en een gele stip om de toename in bezit op de grafiek aan te geven. Eerder heeft Michael Saylor informatie vrijgegeven die verband houdt met de portefeuille volggrafiek van MicroStrategy gedurende meer dan tien opeenvolgende weken. Volgens de regels heeft MicroStrategy altijd de dag na het vrijgeven van het relevante nieuws zijn bezit van Bitcoin verhoogd.</p>
<p><strong>Deze week ontgrendelingsgegevens: SUI, OP en ZETA zullen eenmalig een grote ontgrendeling ervaren</strong></p>
<p>Volgens de gegevens van Token Unlocks zal SUI, OP en ZETA deze week een eenmalige grootschalige tokenontgrendeling hebben, met een totale waarde van meer dan $100 miljoen. Onder hen: Sui (SUI) zal 22,97 miljoen tokens ontgrendelen om 8:00 op 1 maart, ter waarde van ongeveer $78,77 miljoen, wat overeenkomt met 0,74% van de circulatie. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>(OP) zal op 28 februari om 8:00 uur 31,34 miljoen tokens ontgrendelen, ter waarde van ongeveer $37,3 miljoen, wat overeenkomt met 1,93% van de circulatie. De ontgrendelingshoeveelheid van SUI- en OP-tokens is relatief klein in vergelijking met hun marktkapitalisatie, en het effect op de markt zal ook relatief klein zijn.</p>
<h2 id="h2-Markttrends20PImunt20presteerde20sterk20OM20bereikte20een20nieuw20recordhoogte276525"><a name="Markttrends: PI-munt presteerde sterk, OM bereikte een nieuw recordhoogte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: PI-munt presteerde sterk, OM bereikte een nieuw recordhoogte</h2><h3 id="h3-Markt20Hotspots777575"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De nieuwe valuta PI presteerde behoorlijk sterk, met een gemiddeld dagelijks transactievolume van meer dan $500 miljoen op het Gate.io-platform. Ook overtrof zijn prijsprestatie de marktverwachtingen. Na een korte daling naar $0,6 steeg het drie opeenvolgende dagen en stond vandaag genoteerd op $1,6. De marktkapitalisatie bedraagt $10,2 miljard, wat de 12e plaats inneemt op de gehele markt. Deze situatie zal niet lang duren. Het totale bedrag aan PI is 100 miljard, en de huidige circulatie is slechts 6,45%. De FDV van bijna $160 miljard heeft het <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, dat op de derde plaats staat wat betreft marktkapitalisatie. In de toekomst zal het vrijgeven van meer PI munten rechtstreeks van invloed zijn op de markt, maar de markt is nog steeds in een vaag stadium over de token-economie van PI;</p>
<p>De toonaangevende token van de RWA-sector, OM, bleef scherp stijgen, brak door de $9-markering gedurende de dag, en de circulerende marktkapitalisatie overschreed $8 miljard; de RWA-track is het op een na grootste mainstream verhaal in deze ronde van de markt, behalve de AI-sector. De lancering van BlackRock’s BUIDL getokeniseerde fonds in 2024 kan een van de belangrijke drijvende factoren zijn voor de voortdurende populariteit van de RWA-track;</p>
<p>Vorige week opende de nieuwe munt KAITO laag en steeg, brak een keer door de $2, en zakte vervolgens terug naar ongeveer $1.5 voor consolidatie; De huidige circulerende marktkapitalisatie van KAITO is $370 miljoen en de totale circulerende marktkapitalisatie is $1.55 miljard; KAITO heeft sterke investeerders achter zich en werd op de eerste dag van de lancering genoteerd op de meeste belangrijke handelsplatforms, waaronder Gate.io; Sommige gemeenschappen geloven dat KAITO mogelijk een nieuw pad opent voor de aandachtseconomie. Of de markt meegaat in het verhaal van KAITO is het waard om op de lange termijn op te letten.</p>
<h3 id="h3-Gangbare20Munten584584"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC ligt nog steeds in het bereik van $ 94.000 - $ 98.500. De instroom van geld in BTC ETF heeft geen significante ommekeer ondergaan en het fondsniveau is zwak. De AHR999-index van vandaag is 1,14, wat aangeeft dat de huidige <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC prijs</a> is geschikt voor langetermijnbeleggers om in te investeren;</p>
<p>ETH steeg gedurende de dag boven de $2.800. Beïnvloed door het nieuws dat Bybit mogelijk bijna $1,5 miljard aan ETH in OTC zou kunnen kopen, steeg ETH lichtjes; maar vanuit het perspectief van de fundamentals en de financiering van ETH ETF, is de omgeving van ETH niet significant verbeterd;</p>
<p>Altcoins vallen over het algemeen en de markt ontbreekt het aan een collectieve verhaallijn. Het Layer 1-project Sonic en de bijbehorende ecosysteemprojecten zijn nog steeds relatief niche en het waard om in de gaten te houden.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20daalden20allemaal20met20meer20dan20120en20de20Fed20zal20waarschijnlijk20stoppen20met20het20verlagen20van20de20rente20in202025113629"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen daalden allemaal met meer dan 1%, en de Fed zal waarschijnlijk stoppen met het verlagen van de rente in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen daalden allemaal met meer dan 1%, en de Fed zal waarschijnlijk stoppen met het verlagen van de rente in 2025</h2><p>Afgelopen vrijdag daalden alle drie de belangrijkste Amerikaanse aandelenindexen met meer dan 1%, waarbij de S&amp;P 500 met 1,71% daalde tot 6013,13 punten, de Dow Jones Industrial Average met 1,69% daalde tot 43428,02 punten, en de Nasdaq met 2,20% daalde tot 19524,01 punten. Wat betreft Amerikaanse obligaties bedroeg het rendement op de benchmark 10-jarige Amerikaanse obligatie 4,42%, en het rendement op de 2-jarige Amerikaanse obligatie, die het meest gevoelig is voor het rentetarief van de Fed, bedroeg 4,19%.</p>
<p>Afgelopen vrijdag daalden alle drie belangrijke Amerikaanse aandelenindexen met meer dan 1%, maar tegelijkertijd daalde de 2-jarige Amerikaanse schatkistrendement, dat het meest gevoelig is voor de beleidsrente van de Fed, ook met 0,1%. De nieuwe Amerikaanse februari PMI-gegevens hebben investeerders bezorgdheid over economische vertraging en aanhoudende inflatie. Het resultaat van Nvidia deze week kan de richting van de Amerikaanse aandelen beïnvloeden. Analisten voorspellen dat de Federal Reserve haar referentierentevoet pas in 2025 eenmaal zal verlagen, en de kans is groot dat zij de rente helemaal niet zal verlagen.</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 beleggingsaanbeveling. 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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>