RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZWVmdCBvcG5pZXV3IGRlICQ5NUsgZ3JlbnMgYmVyZWlrdCwgYW5hbGlzdGVuIHplZ2dlbiBkYXQgZGUgaG9vcCBvcCBlZW4gZXhwbG9zaWV2ZSBncm9laSB2YW4gYWx0Y29pbnMgYWZuZWVtdA==

2025-05-06, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17465033415.6.webp" alt="">
</p><h2 id="h2-Crypto20Dagelijks20Overzicht20Goldman20Sachs20verwacht20dat20de20Fed20dit20jaar20drie20keer20de20rente20zal20verlagen20en20het20rapport20zegt20dat20BTC20naar20verwachting20zijn20bullmarkt20zal20voortzetten20na20stabilisatie20op2095000477782"><a name="Crypto Dagelijks Overzicht: Goldman Sachs verwacht dat de Fed dit jaar drie keer de rente zal verlagen, en het rapport zegt dat BTC naar verwachting zijn bullmarkt zal voortzetten na stabilisatie op $95,000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Goldman Sachs verwacht dat de Fed dit jaar drie keer de rente zal verlagen, en het rapport zegt dat BTC naar verwachting zijn bullmarkt zal voortzetten na stabilisatie op $95,000</h2><p>Volgens de gegevens van Farside Investors bedraagt de totale uitstroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s gisteren was $105 miljoen. Daarvan had Fidelity FBTC een uitstroom van $57.8 miljoen en had Grayscale GBTC een nettouitstroom van $16.4 miljoen. De instroom- en uitstroomgegevens van ETH ETF gisteren waren nagenoeg verwaarloosbaar.</p>
<p><strong>Goldman Sachs: De Fed wordt verwacht de rentetarieven tegen 2025 drie keer te verlagen</strong></p>
<p>Op 5 mei voorspelde Goldman Sachs dat de Federal Reserve respectievelijk in juli, september en oktober de rentetarieven met 25 basispunten zou verlagen, vanwege de recessierisico’s die ontstaan door tarieven en handelsonzekerheid. Jan Hatzius, hoofdeconoom van Goldman Sachs, zei dat de houding van de Fed voorzichtiger was dan de markt had verwacht. Hoewel de drempel van de Fed voor renteverlagingen hoger is dan in 2019, gelooft Goldman Sachs dat stijgende werkloosheid de Fed nog steeds kan aanzetten tot actie ondanks hogere inflatie.</p>
<p><strong>Analyse: de kracht van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft de hoop op een Altcoin-rally getemperd</strong></p>
<p>Matrixport plaatste op het X-platform dat het afgelopen jaar crypto Twitter bijna elke maand heeft opgeroepen tot Altcoin-herstel, maar tevergeefs. Maar het Altcoin-herstel wordt niet gedreven door grafiekpatronen of een veronderstelde achterstand op de acties van Bitcoin. In plaats daarvan vertrouwen ze op de daling van de Bitcoin-dominantie en de stijging van het totale <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> cap. Terwijl <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> dominantie stijgt, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> onderpresteert, en maar weinig andere cryptocurrencies komen naar voren als geloofwaardige concurrenten in deze cyclus. Zonder een sterke alternatieve verhaallijn of leiderschap kunnen andere cryptocurrencies achterblijven. Ons andere cryptoprestatiemodel ondersteunt momenteel deze visie en blijft bullish op Bitcoin.</p>
<p><strong>Rapport: Als Bitcoin stabiliseert op $95.000, wordt verwacht dat de stierenmarktstructuur zal aanhouden</strong></p>
<p>Een instelling heeft onlangs een rapport uitgebracht waarin staat: “Bitcoin sloot april af met een stijging van 14,08%, waarmee het niet alleen zijn historisch gemiddelde prestatie in april overtrof, maar ook met succes de diepe correctie aan het begin van de maand omkeerde. Het steeg van het dieptepunt in april van $74.501 naar bijna $98.000, een stijging van meer dan 32%, wat de veerkracht ervan aantoont in het licht van macro-economische onrust en verschuivende risicosentiment. De $95.000 grens van Bitcoin, de onderste grens van de vorige driemaandelijkse consolidatie, is een belangrijk technisch ondersteuningsniveau geworden. Als dit niveau gehandhaafd kan blijven, vooral wanneer de huidige prijs boven de kostprijs van kortetermijnhouders ($93.340) blijft, kan dit de basis leggen voor een terugkeer naar nieuwe hoogtepunten.</p>
<h2 id="h2-Markttrends20BTC20is20opnieuw20binnen20de209500020markering20gekomen20PARTI2024uursstijging20overschreed20356232"><a name="Markttrends: BTC is opnieuw binnen de $9,5000 markering gekomen, PARTI 24-uursstijging overschreed 35%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC is opnieuw binnen de $9,5000 markering gekomen, PARTI 24-uursstijging overschreed 35%</h2><h3 id="h3-Markt20Hotspots385001"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>PARTI steeg boven de $0.34, met een stijging van meer dan 35% in 24 uur. Als een token voor de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> maker economie, de token richt zich op het gedecentraliseerde contentplatformecosysteem, maar het token-economisch model is nog niet volledig geïmplementeerd en de werkelijke toepassingsondersteuningsmogelijkheden moeten nog worden getest.</p>
<p>ICX steeg met meer dan 20%. Deze token is een vertegenwoordiger van de lokale openbare keten van Zuid-Korea. Het presteerde goed op de bullmarkt in 2018, maar zijn marktpopulariteit en handelsactiviteit zijn nog steeds inferieur aan andere mainstreamprojecten, en het is meer geschikt voor de aandacht van middellange en langetermijnbeleggers.</p>
<h3 id="h3-Gangbare20Munten50929"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC bleef schommelen en doorbrak opnieuw de $95.000 grens tijdens de sessie. Uit de laatste gegevens blijkt dat het marktaandeel van BTC kortstondig boven de 65% uitkwam, wat een nieuw hoogtepunt sinds februari 2021 betekent. Analisten geloven dat $95.000 een belangrijke grens voor BTC zal zijn. Als het stand kan houden, heeft de bullmarkt nog steeds hoop om door te gaan.</p>
<p>ETH’s potentieel is duidelijk onvoldoende. Het schommelde naar beneden tegen de achtergrond van de opleving van BTC, en zakte tijdens de sessie onder de $1.800. De zwakke in- en uitstroomgegevens van ETF’s duiden op de aanhoudende zwakte van marktaandacht.</p>
<p>Altcoins stegen en daalden verschillend, terwijl sectoren zoals AI en CeFi iets herstelden. Analyse wees erop dat naarmate het marktaandeel van BTC toenam, de hoop op een doorbraak van Altcoins steeds slanker werd.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20vertoonden20tekenen20van20zwakte20SampP20beindigde20negen20opeenvolgende20dagen20van20winst284302"><a name="Macro Nieuws: Amerikaanse aandelen vertoonden tekenen van zwakte, S&amp;P beëindigde negen opeenvolgende dagen van winst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen vertoonden tekenen van zwakte, S&amp;P beëindigde negen opeenvolgende dagen van winst</h2><p>De scherpe rally op de Amerikaanse aandelenmarkt vertoonde maandag tekenen van zwakte. Ondanks de publicatie van enkele economische gegevens die beter waren dan verwacht en de nieuwe toezegging van de minister van Financiën aan een handelsovereenkomst, daalde de S&amp;P 500 met 0,6%, waarmee een einde kwam aan zijn winstreeks van negen dagen, terwijl de Dow Jones met 0,2% daalde, of ongeveer 99 punten.</p>
<p>Op 5 mei, Eastern Time, toonden gegevens vrijgegeven door het Institute for Supply Management (ISM) aan dat de activiteit in de dienstensector in april opnieuw versnelde na een daling in de vorige maand, en stijgende tarieven leidden tot stijgende grondstofprijzen. De gegevens toonden aan dat de Amerikaanse ISM PMI-index voor de dienstensector in april 51,6 bedroeg, terugkerend naar het expansiebereik (boven 50), aanzienlijk hoger dan de verwachte 50,2, en de vorige waarde was 50,8, die onverwacht daalde naar een dieptepunt van negen maanden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Orisi 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 beleggingsaanbevelingen. Alle investeringen brengen inherente risico’s met zich mee; verstandig besluitvorming is essentieel.<br><div></div>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle gevallen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br><p></p><br></em></div></div></div></div>