RGFnZWxpamtzIG5pZXV3cyB8IEhldCBoYW5kZWxzYmVsZWlkIHZhbiBUcnVtcCBibGlqZnQgdm9vciBvbnJ1c3Qgem9yZ2VuIG9wIGRlIHdlcmVsZG1hcmt0ZW4sIGRlIEZlZCBrYW4gZGUgcmVudGV2ZXJsYWdpbmcgaGVydmF0dGVuIGluIGhldCAzZSBrd2FydGFhbA==

2025-04-11, 03:49

<p><img src="https://gimg2.gateimg.com/image/article/17443431564.11.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Vitalik20heeft20het20Ethereum20L120privacy20roadmap20vrijgegeven20de20Fed20kan20in20het20derde20kwartaal20de20renteverlaging20hervatten109505"><a name="Crypto Dagelijks Overzicht: Vitalik heeft het Ethereum L1 privacy roadmap vrijgegeven, de Fed kan in het derde kwartaal de renteverlaging hervatten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Vitalik heeft het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L1 privacy roadmap vrijgegeven, de Fed kan in het derde kwartaal de renteverlaging hervatten</h2><p>Volgens de gegevens van Farside Investors was de Amerikaanse <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs hadden een totale nettostroom van $149 miljoen, waarbij zes opeenvolgende dagen van nettostromen werden bereikt. Daarvan had Fidelity FBTC een uitstroom van $74,5 miljoen, en andere BTC ETF’s hadden voornamelijk kleine uitstroom. Gisteren, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETFs hadden een uitstroom van $45 miljoen, Fidelity FETH had een uitstroom van $36 miljoen, en BlackRock ETHA-gegevens zijn nog niet bijgewerkt.</p>
<p>Volgens alternatieve gegevens staat de crypto fear en greed Index van vandaag op 21 (gisteren was het 25), en de marktsentiment is nog steeds in de paniekfase.</p>
<p><strong>Vitalik Released <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L1 Privacy Roadmap</strong></p>
<p><a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> mede-oprichter Vitalik heeft de Ethereum L1 privacy roadmap (minimalistische versie) uitgebracht, die vier belangrijke vormen van privacy behandelt: privacy van on-chain betalingen, gedeeltelijke anonimisering van on-chain activiteiten binnen applicaties, privacy van on-chain lezingen (d.w.z. RPC-oproepen) en anonimiteit op netwerkniveau.</p>
<p>Deze routekaart kan worden gecombineerd met de langetermijnroutekaart, die diepere veranderingen aan L1 zou kunnen inhouden, zoals privacybehoudende toepassingsspecifieke Rollups, of andere complexere functies. De routekaart stelt maatregelen voor zoals het integreren van privacytools (zoals Railgun), standaardiseren op ‘één adres per toepassing’, het implementeren van FOCIL en EIP-7701. Vitalik benadrukte dat het doel is om standaard privacytransfers te bereiken, niet-gecorreleerde activiteiten tussen toepassingen, en om privacybedreigingen op de keten en RPC-nodes te weerstaan, waardoor een nieuwe norm wordt gesteld voor privacybescherming in het Ethereum-ecosysteem.</p>
<p>Vitalik merkte op dat deze routekaart tot doel heeft het privacy niveau van het Ethereum ecosysteem op de lichtst mogelijke manier te verbeteren, terwijl de basis wordt gelegd voor diepere langetermijnoplossingen (zoals L1 verbeteringen of dedicated Rollups).</p>
<p><strong>De huidige mainstream CEX en DEX financieringsrentes zijn licht hersteld, maar over het algemeen nog steeds bearish</strong></p>
<p>Volgens Coinglass-gegevens zijn de huidige financieringstarieven voor mainstream CEX en DEX lichtjes hersteld, maar over het algemeen nog steeds bearish. De specifieke financieringstarieven voor mainstream valuta worden getoond in de bijgevoegde figuur.</p>
<p>Funding rates are de tarieven die door crypto-handelsplatforms worden vastgesteld om een balans te behouden tussen de contractprijs en de prijs van het onderliggende actief, en zijn meestal van toepassing op eeuwigdurende contracten. Het is een mechanisme om fondsen uit te wisselen tussen long- en short-handelaren. Het handelsplatform brengt deze vergoeding niet in rekening, en het wordt gebruikt om de kosten of voordelen van handelaren die contracten aanhouden aan te passen om de contractprijs dicht bij de prijs van het onderliggende actief te houden.</p>
<p>Wanneer de financieringsrente 0,01% is, duidt dit op het basistarief. Wanneer de financieringsrente hoger is dan 0,01%, duidt dit erop dat de markt over het algemeen bullish is. Wanneer de financieringsrente lager is dan 0,005%, duidt dit erop dat de markt over het algemeen bearish is.</p>
<p><strong>Standpunt: De Fed wordt verwacht aan de zijlijn te blijven en de renteverlagingen in het derde kwartaal te hervatten</strong></p>
<p>Het onderzoeksrapport van CICC wees erop dat zowel de kern- als de algemene CPI-inflatie in de Verenigde Staten in maart daalde, beide lager dan de marktverwachtingen. De vertraging in de inflatie toont aan dat de totale vraag in de Verenigde Staten verzwakt was voordat de ‘wederkerige tarieven’ arriveerden, zoals de scherpe daling van de olieprijzen, vliegtickets en hotelprijzen.</p>
<p>De impact van tariefschokken op de kernprijzen van grondstoffen is nog niet volledig weerspiegeld, maar dit kan in de komende maanden beginnen door te werken. Vooruitkijkend wordt verwacht dat het prijsniveau in de VS in het tweede kwartaal kan stijgen voordat de vraag uiteindelijk de inflatie onderdrukt. Verwacht wordt dat de Federal Reserve zal blijven afwachten en niet op korte termijn de rente zal verlagen. Het kan de renteverlagingen in het derde kwartaal hervatten.</p>
<h2 id="h2-Markttrends20BTC20ETF20had20gedurende20zes20opeenvolgende20dagen20nettostromen20MANEKI20steeg20in20n20dag20met2030928021"><a name="Markttrends: BTC ETF had gedurende zes opeenvolgende dagen nettostromen, MANEKI steeg in één dag met 30%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC ETF had gedurende zes opeenvolgende dagen nettostromen, MANEKI steeg in één dag met 30%</h2><h3 id="h3-Markt20Hotspots691165"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De nieuwe munt BABY werd gisteravond gelanceerd op belangrijke mainstream handelsplatforms, waaronder Gate.io, waarbij hij een hoogtepunt van $0.17 bereikte en nu is terugglen tot ongeveer $0.081; de huidige volledige circulatiemarktwaarde van BABY is $810 miljoen, en de waardering van de laatste financieringsronde van het project is ook $800 miljoen; BABY is de inheemse token van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> staking protocol Babylon. According to community feedback, BABY has given very few airdrops to users, and BABY should still be under a highly controlled state;</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> kettingkat meme-munten POPCAT en MANEKI schoten omhoog. POPCAT overschreed ooit $2 miljard aan marktwaarde in omloop aan het einde van 2024, en MANEKI bereikte ook een recordhoogte van $250 miljoen. Beide tokens zijn meer dan 90% gedaald vanaf hun historische hoogtepunten. MANEKI is een Japanse gelukskat beeldmunt-meme. De huidige marktwaarde in omloop is slechts $10 miljoen, en de on-chain liquiditeitspool is zo hoog als $5 miljoen.</p>
<h3 id="h3-Mainstream20Munten255460"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>De intraday volatiliteit van BTC is toegenomen en wordt duidelijk beïnvloed door het macro niveau. Daarnaast heeft de BTC ETF gedurende zes opeenvolgende dagen netto uitstroom ervaren. De AHR999-index van vandaag is 0,68, wat aangeeft dat de huidige prijs geschikt is voor langetermijnbeleggers om regelmatig te investeren;</p>
<p>ETH volgde de markt ups en downs, maar de stijging was aanzienlijk zwakker dan BTC. ETH/BTC daalde opnieuw naar ongeveer 0.0192;</p>
<p>Altcoins vielen over het algemeen en de markt ontbrak aan een collectieve narratieve hotspot.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20zijn20collectief20gekelderd20en20de20waarschijnlijkheid20dat20de20Fed20de20rente20in20mei20verlaagt20is20gedaald20naar2019828038"><a name="Macro Nieuws: Amerikaanse aandelen zijn collectief gekelderd en de waarschijnlijkheid dat de Fed de rente in mei verlaagt, is gedaald naar 19%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen zijn collectief gekelderd en de waarschijnlijkheid dat de Fed de rente in mei verlaagt, is gedaald naar 19%</h2><p>De drie belangrijkste Amerikaanse aandelenindices daalden gezamenlijk, waarbij de S&amp;P 500 met 3,46% daalde tot 5.268,05 punten, de Dow Jones Industrial Average met 2,50% daalde tot 39.593,66 punten, en de Nasdaq met 4,31% daalde tot 16.387,31 punten. Wat betreft Amerikaanse obligaties, bedroeg het rendement van de referentie 10-jarige Amerikaanse obligatie 4,40%, en het rendement van de 2-jarige Amerikaanse obligatie, die het meest gevoelig is voor het rentetarief van de Fed, bedroeg 3,84%.</p>
<p>Nu de markt steeds meer inzet op de Fed om de rente te verlagen, hebben verschillende Fed-functionarissen intensief gesproken, waarbij benadrukt wordt dat het beheersen van inflatie de hoogste prioriteit heeft, gewaarschuwd wordt dat tarieven blijvende prijsdruk kunnen veroorzaken, en gesuggereerd wordt dat er geen haast is om op korte termijn de rente te verlagen.</p>
<p>Ray Dalio, oprichter van Bridgewater Associates, zei dat Trump’s tariefbeleid heeft gezorgd voor aanhoudende onrust op de wereldwijde financiële markten, waardoor investeerders in ‘een soort trauma, schok of angst’ zijn beland, wat de reputatie van de Verenigde Staten ernstig heeft geschaad. Dalio waarschuwde dat de Amerikaanse economie waarschijnlijk in een recessie zal belanden en maakt zich ook zorgen over verdere escalatie van conflicten. De huidige economische situatie is het resultaat van een verscheidenheid aan complexe factoren, waaronder financiële marktonrust, politieke beleidsonzekerheid en internationale spanningen. ‘Dit is geen gewone recessie. We veranderen de monetaire orde.’</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; verstandige 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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>