RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBzY2hvbW1lbGRlIGVuIHRyb2sgb3BuaWV1dyB0ZXJ1ZywgZ3JvZWkgdmFuIEFtZXJpa2FhbnNlIG5vbi1mYXJtIGxvbmVuIG92ZXJ0cm9mIHZlcndhY2h0aW5nZW4=

2025-05-05, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/17464158275.5.webp" alt="">
</p><h2 id="h2-Crypto20Dagelijkse20Samenvatting20Analisten20zeggen20dat20Bitcoin20op20elk20moment20de20dominantie20van20goud20kan20overstijgen20Trump20herhaalde20zijn20steun20voor20cryptocurrencies103901"><a name="Crypto Dagelijkse Samenvatting: Analisten zeggen dat Bitcoin op elk moment de dominantie van goud kan overstijgen, Trump herhaalde zijn steun voor cryptocurrencies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Analisten zeggen dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op elk moment de dominantie van goud kan overstijgen, Trump herhaalde zijn steun voor cryptocurrencies</h2><p>Volgens de gegevens van Farside Investors is de totale instroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs afgelopen vrijdag was $674 miljoen. Onder hen, BlackRock IBIT instroom was $674 miljoen, en de instroom en uitstroom van andere ETF’s waren verwaarloosbaar. Afgelopen vrijdag was de instroom van ETH ETF’s $20,1 miljoen, waarvan BlackRock ETHA een nettostroom van $20,1 miljoen had, en andere ETF’s hadden geen instroom- en uitstroomgegevens.</p>
<p><strong>Fidelity: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> kan op elk moment de dominantie van goud overstijgen</strong></p>
<p>Fidelity gaf onlangs een hint dat Bitcoin binnenkort mogelijk het stokje van goud zal overnemen. Jurrien Timmer, wereldwijd macro-directeur van Fidelity Investments, publiceerde onlangs een gedetailleerde analyse van de dynamische relatie tussen Bitcoin en goud. Hij haalde gegevens aan van Fidelity Management and Research Company (FMR Co) en Bloomberg, analyseerde de veranderende trends van de Sharpe-ratio (een maatstaf voor risico-gecorrigeerde rendementen) van de twee activa, en wees erop dat hun relatieve prestaties mogelijk op een keerpunt staan.</p>
<p>De grafiek die hij deelde laat zien dat het recente rendement van goud $22.51 is, terwijl dat van Bitcoin $13.22 is, waarbij het rendement van goud met 4 keer wordt vergroot om de lagere volatiliteit te weerspiegelen, terwijl het rendement van Bitcoin niet evenredig wordt aangepast en blijft op 1 keer. Zijn opmerking zei: “Het lijkt erop dat dit het leidende moment van Bitcoin kan zijn, aangezien de Sharpe-ratio momenteel -0.40 is, terwijl die van goud 1.33 is. Daarom zouden we weleens een stokje-overdracht van goud naar Bitcoin kunnen meemaken.”</p>
<p><strong>Trump herhaalde zijn steun voor cryptocurrencies</strong></p>
<p>Trump heeft onlangs zijn steun voor cryptocurrencies herhaald, waarbij hij zei dat crypto-activa veerkrachtig zijn gebleken tijdens marktdalingen en nu wijd geaccepteerd zijn. Hij zei dat de Verenigde Staten voorop moeten blijven lopen in digitale activa-innovatie, anders zal het achterblijven bij landen zoals China.</p>
<p>Trump zei in een interview op NBC News’ “Meet the Press.” “Ik denk dat cryptocurrency belangrijk is omdat als we het niet doen, China het zal doen,” zei hij. “Het is nieuw en erg populair en erg hot.” Hij voegde eraan toe dat cryptocurrencies ‘veel sterker hebben gepresteerd dan de rest van de markt’ tijdens de marktdownturn.</p>
<p><strong>Michael Saylor kan opnieuw hinten naar het vergroten van BTC bezittingen</strong></p>
<p>Michael Saylor, oprichter van Strategy, heeft opnieuw informatie vrijgegeven over Bitcoin Tracker. Hij zei: ‘Te veel blauw, niet genoeg oranje.’ Volgens de vorige regels onthult Strategy altijd informatie over het verhogen van haar Bitcoin-bezittingen de dag nadat het relevante nieuws is vrijgegeven.</p>
<h2 id="h2-Markttrends20BTC20fluctueerde20neerwaarts20en20Altcoins20daalden20over20het20algemeen260643"><a name="Markttrends: BTC fluctueerde neerwaarts en Altcoins daalden over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC fluctueerde neerwaarts en Altcoins daalden over het algemeen</h2><h3 id="h3-Markt20Hotspots859048"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Tokens zoals ENA, SPEC en MOVE zullen volgende week in grote hoeveelheden worden vrijgegeven, waarbij ENA ongeveer $50 miljoen waard is. De vrijgave van fondsen kan enige druk leggen op gerelateerde tokens;</p>
<p>SXT heeft aangekondigd dat 28% van de totale SXT-tokens zal worden gebruikt voor gemeenschapsbeloningen, inclusief retroactieve claims en stakingbeloningen. 51,7% van de totale tokens is toegewezen aan deelnemers die bijdragen aan het ecosysteem, of ze nu het netwerk gebruiken, projecten ontwikkelen of de groei ervan ondersteunen.</p>
<h3 id="h3-Hoofdstroommunten667885"><a name="Hoofdstroommunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoofdstroommunten</h3><p>BTC fluctueerde neerwaarts en stond na een daling boven de $94.000 tijdens de sessie. Vorige week herstelde de rally van Bitcoin, maar de algemene marktvisie is dat het slechts een omkeer is in plaats van een herstel. Volgens gegevens van Alternative.me daalde de cryptovrees- en hebzuchtindex van vandaag naar 52 (de index stond gisteren op 64), wat aangeeft dat de markt in een ‘neutrale staat’ verkeert. Volgens gegevens van Coinglass tonen de huidige mainstream CEX- en DEX-financieringspercentages aan dat de markt over de hele linie bearish is geworden;</p>
<p>ETH volgde de markt ups en downs, zonder enige onafhankelijke trend, en bleef consolideren rond $1,800;</p>
<p>Altcoins vielen over het algemeen en ontwikkelden geen onafhankelijke trend. Het langverwachte Altcoin-seizoen is nog steeds nergens te bekennen.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20bleven20stijgen20gedurende20enkele20dagen20en20de20groei20van20het20aantal20banen20buiten20de20landbouw20overtrof20de20verwachtingen736326"><a name="Macro nieuws: Amerikaanse aandelen bleven stijgen gedurende enkele dagen, en de groei van het aantal banen buiten de landbouw overtrof de verwachtingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen bleven stijgen gedurende enkele dagen, en de groei van het aantal banen buiten de landbouw overtrof de verwachtingen</h2><p>Amerikaanse aandelen verlengden hun meerdaagse rally op vrijdag, waarbij de Dow, S&amp;P 500 en de Nasdaq Composite allemaal met minstens 1,4% stegen. De S&amp;P 500 sloot hoger voor een negende opeenvolgende sessie, de langste winstreeks sinds 2004, en herstelde een scherpe daling nadat president Trump begin april brede handelsbeperkingen had aangekondigd.</p>
<p>Het nieuws kwam nadat de Amerikaanse non-farm payrolls meer dan verwacht waren gestegen, wat erop wijst dat de arbeidsmarkt veerkrachtig blijft ondanks de onrust veroorzaakt door het handelsbeleid van de regering-Trump. Gegevens toonden aan dat de werkgelegenheid vorige maand met 177.000 banen toenam, nadat de banengroei in maart naar beneden was bijgesteld tot 185.000. Economen hadden een toename van 138.000 banen voorspeld. Ondertussen zei China vorige week dat het de mogelijkheid van handelsgesprekken met de Verenigde Staten aan het evalueren was, waarbij werd toegevoegd dat elke dialoog gebaseerd moet zijn op oprechtheid en de verwijdering van eenzijdige tarieven.</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 beleggingsadvies. 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 vermeld. In alle gevallen zal juridische stappen worden ondernomen wegens schending van het auteursrecht.<br><p></p><br></em></div></div></div></div>