RGFnZWxpamtzIG5pZXV3cyB8IEZlYnJ1YXJpIENQSSB3YXMgbGFnZXIgZGFuIHZlcndhY2h0LCBhbHRjb2lucyBoZXJzdGVsZGVuLCBQSSBlbiBSRUQtdG9rZW5zIHN0ZWdlbiBtZXQgbWVlciBkYW4gMjAl

2025-03-13, 02:49

<p><img src="https://gimg2.gateimg.com/image/article/17418340809.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Blockchaingerelateerde20termen20bereiken20een20nieuw20hoogtepunt20in20SECdocumenten20en2099220van20de20nieuwe20aandelen20van20Trumps20cryptoproject20WLFI20zijn20verkocht321880"><a name="Crypto Dagelijkse Samenvatting: Blockchain-gerelateerde termen bereiken een nieuw hoogtepunt in SEC-documenten, en 99,2% van de nieuwe aandelen van Trump’s crypto-project WLFI zijn verkocht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Blockchain-gerelateerde termen bereiken een nieuw hoogtepunt in SEC-documenten, en 99,2% van de nieuwe aandelen van Trump’s crypto-project WLFI zijn verkocht</h2><p>Op het moment van schrijven, volgens de gegevens van Farside Investors, gisteren in de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF had a netto uitstroom van $60.39 miljoen, waarvan ARKB een netto instroom had van $82.6 miljoen, BTCO had een netto uitstroom van $12.4 miljoen, en GBTC had een netto uitstroom van $11.8 miljoen. De netto uitstroom van ETF van gisteren beëindigde een vierdaagse reeks van netto uitstroom.</p>
<p>Gisteren, de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had a net outflow of $10.4 miljoen, waarvan FETH een nettostroom van $3.7 miljoen had en Grayscale ETH een nettostroom van $3.5 miljoen had.</p>
<p><strong>Blockchain-gerelateerde termen in SEC-indieningen bereiken in februari een recordhoogte</strong></p>
<p>Termen met betrekking tot blockchain in de documenten van de U.S. Securities and Exchange Commission (SEC) bereikten in februari een recordhoogte, met de EDGAR-database die meer dan 5.000 gerelateerde vermeldingen registreerde, wat een voortdurende stijgende trend laat zien sinds midden 2023. De algemene marktvisie is dat deze groei in overeenstemming is met de belangrijke verschuiving van de SEC in haar regelgevende houding ten opzichte van de cryptobranche.</p>
<p><strong>De huidige belangrijkste CEX en DEX financieringspercentages tonen aan dat de markt nog steeds bearish is</strong></p>
<p>Volgens Coinglass-gegevens zijn de huidige hoofdstroom CEX- en DEX-financieringsrentetarieven nog steeds minder dan 0,005% op 13 maart, wat aangeeft dat de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> is nog steeds in een bearish trend. De financieringsrente is een rente die door het crypto-handelsplatform wordt vastgesteld om een balans te behouden tussen de contractprijs en de prijs van het onderliggende actief. Het is meestal van toepassing op eeuwigdurende contracten en wordt gebruikt als een fondsuitwisselingsmechanisme tussen long en short handelaren.</p>
<p><strong>99.2% van de nieuwe aandelen van Trump’s crypto-project WLFI zijn verkocht</strong></p>
<p>Volgens de officiële website is tot 13 maart 99,2% van de extra 5% van het Trump crypto-project WLFI (5 miljard tokens) verkocht. Onlangs is de prijs van de extra 5% aanbod van het Trump crypto-project WLFI gestegen naar $0,05, terwijl de vorige prijsronde slechts $0,015 bedroeg.</p>
<p><strong>Mening: Naar verwachting zal de Amerikaanse minister van Financiën op 5 mei verduidelijken welke budgetneutrale maatregelen er genomen zullen worden voor de aankoop van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a></strong></p>
<p>K33-analisten zeiden dat ondanks de algemene marktverkoop als gevolg van zorgen over een recessie, de uitvoerende order van president Trump voor de “Strategische <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Reserve” nog steeds een “grote zaak” is. Bovendien verwachten analisten dat de Amerikaanse minister van Financiën Scott Bessent de budgetneutrale Bitcoin-aanwervingsmaatregelen zal verduidelijken vóór 5 mei.</p>
<h2 id="h2-Markttrends20Altcoins20begonnen20te20herstellen20PI20en20REDtokens20stegen20in202420uur20met20meer20dan2020431993"><a name="Markttrends: Altcoins begonnen te herstellen, PI- en RED-tokens stegen in 24 uur met meer dan 20%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Altcoins begonnen te herstellen, PI- en RED-tokens stegen in 24 uur met meer dan 20%</h2><h3 id="h3-Markt20Hotspots632458"><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 is de markt in een volatiele modus terechtgekomen, waarbij zowel long- als shortposities geliquideerd werden. In totaal werden wereldwijd 93.200 mensen geliquideerd, met een totaal liquidatiebedrag van $270 miljoen, waarvan longposities werden geliquideerd voor $149 miljoen en shortposities werden geliquideerd voor $121 miljoen.</p>
<p>Gegevens tonen aan dat het totale openstaande belang van Bitcoin-futures 567.130 BTC is, waarvan CME de leiding heeft met 144.770 BTC. Hoe hoger het aantal openstaande contracten, hoe groter de potentiële marktvolatiliteit, maar het moet worden opgemerkt dat het huidige totale openstaande belang met ongeveer 50% is afgenomen sinds het begin van het jaar, maar de absolute waarde is nog steeds hoger dan het begin van de markt op 24 november.</p>
<h3 id="h3-Gangbare20Munten55931"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>Bitcoin handhaafde een zwak herstelde staat. Op het moment van schrijven werd Bitcoin genoteerd op $84,108, een stijging van 1% in 24 uur. Het moet ook worden opgemerkt dat rond $84,500 een duidelijk opwaartse drukpunt is.</p>
<p><a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> wordt momenteel verhandeld voor $1.910, een daling van 1,2% in 24 uur, en de prestaties zijn nog steeds zwak. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is ongeveer 25% gedaald sinds zijn hoogtepunt in maart en bevindt zich momenteel in een volatiele range van $1.840-$1.950.</p>
<p>Altcoins herstelden over het algemeen, maar het algehele herstel was beperkt. Layer2 en Cefi presteerden het beste, met respectievelijk een stijging van 2,95% en 2,46% in 24 uur, beide minder dan 3%. Echter, de eerder populaire valuta PI en RED herstelden scherp, met een stijging van meer dan 20% in 24 uur.</p>
<h2 id="h2-Macro20Nieuws20Februari20CPI20was20lager20dan20verwacht20Tesla20steeg20meer20dan20799031"><a name="Macro Nieuws: Februari CPI was lager dan verwacht, Tesla steeg meer dan 7%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Februari CPI was lager dan verwacht, Tesla steeg meer dan 7%</h2><p>De inflatie in de Verenigde Staten is in februari over de hele linie afgenomen, waarbij de kern-CPI-groeisnelheid daalde naar het laagste niveau in vier jaar. Op 12 maart publiceerde het Bureau of Labor Statistics van de Verenigde Staten gegevens waaruit blijkt dat de Amerikaanse CPI in februari op jaarbasis met 2,8% steeg, het laagste sinds november vorig jaar; de verwachte waarde was 2,9%, en de vorige waarde was 3%. De Amerikaanse CPI steeg met 0,2% op maandbasis in februari, het laagste sinds oktober vorig jaar. Handelaren hebben hun inzet op de Federal Reserve verhoogd om de rentetarieven te verlagen, in de verwachting van minstens twee renteverlagingen dit jaar.</p>
<p>De afkoeling van de inflatiegegevens verminderde economische zorgen en de drie belangrijkste Amerikaanse aandelenindexen stegen en daalden: de S&amp;P 500-index sloot 0,49% hoger. De Dow Jones Industrial Average daalde met 0,20%. De Nasdaq sloot 1,22% hoger. De Nasdaq 100 sloot 1,14% hoger. Technologieaandelen herstelden scherp, waarbij Tesla meer dan 7% steeg en Nvidia meer dan 6% steeg.</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 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 zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>