RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBzbG9lZyBvcG5pZXV3IGVlbiBuaWV1dyBob29ndGVwdW50IGJpbm5lbiBkZSBkYWcsIE1pY3JvU3RyYXRlZ3kgemFsICQyLDYgbWlsamFyZCBhYW4gb2JsaWdhdGllcyB1aXRnZXZlbiBvbSBCVEMgdGUga29wZW4u

2024-11-21, 04:44

<p><img src="https://gimg2.gateimg.com/image/article/173216396811.21.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20zagen20een20dagelijkse20instroom20van2076020miljoen20MicroStrategy20zal202620miljard20aan20obligaties20uitgeven20om20BTC20te20kopen364212"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s zagen een dagelijkse instroom van $760 miljoen, MicroStrategy zal $2.6 miljard aan obligaties uitgeven om BTC te kopen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s zagen een dagelijkse instroom van $760 miljoen, MicroStrategy zal $2.6 miljard aan obligaties uitgeven om BTC te kopen</h2><p>Volgens gegevens van Farside Investor, Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hadden gisteren een nettostroom van $760 miljoen. De nettostroom van BlackRock’s IBIT was $625 miljoen, en de nettostroom van Fidelity’s FBTC was $134 miljoen.</p>
<p>Gisteren heeft de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s ondervonden een uitstroom van $47 miljoen. De uitstroom van Fidelity FETH was $30,7 miljoen, de uitstroom van Grayscale ETHE was $16,3 miljoen, en de gegevens van BlackRock ETHA zijn nog niet bijgewerkt.</p>
<p><strong>ETH/BTC-wisselkoers bereikte een nieuw dieptepunt van drie jaar en raakte 0,033.</strong></p>
<p>Volgens de marktinformatie van Gate.io daalde de ETH/BTC-wisselkoers naar 0,033, nu gerapporteerd op 0,03303, met een daling van 2,88% in 24 uur, waarmee het zijn laagste punt sinds april 2021 heeft bereikt.</p>
<p><strong>MicroStrategy zal $2,6 miljard aan obligaties uitgeven om te kopen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, resulterend in een drijvende winst van $14.85 miljard op zijn Bitcoin-bezittingen</strong></p>
<p>MicroStrategy heeft aangekondigd dat het converteerbare senior notes ter waarde van $2,6 miljard zal uitgeven en de opbrengst zal gebruiken om <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te kopen. De omvang van deze uitgifte is vergroot in vergelijking met het eerder aangekondigde totale hoofdbedrag van $1,75 miljard, en de uitgifte wordt naar verwachting afgerond op 21 november 2024.</p>
<p>Deze notities zullen de ongedekte senior schulden van MicroStrategy zijn, die niet regelmatig rente zullen opbrengen en het kapitaal van de notities zal niet toenemen. Tenzij teruggekocht, ingelost of vooraf omgezet volgens de voorwaarden, zullen deze notities op 1 december 2029 vervallen. Op of na 4 december 2026 kan MicroStrategy alle of een deel van de notities voor contant geld inlossen tegen een inlossingsprijs gelijk aan 100% van het hoofdbedrag van de in te lossen notities, plus achterstallige en onbetaalde speciale rente.</p>
<p>Volgens marktinformatie is de marktkapitalisatie van MicroStrategy vandaag de dag de $100 miljard overschreden, met een huidige marktkapitalisatie van $111.39 miljard. De aandelenkoers steeg tijdens de handelssessie van vandaag met 14.64% en staat nu op $494.69, wat een nieuwe historische hoogte is. MicroStrategy is vandaag ook opgenomen in de top 100 Amerikaanse beursgenoteerde bedrijven op basis van marktkapitalisatie, waarbij ze naar de 33e plaats op de NASDAQ, de 89e plaats op de S&amp;P 500-index en de 85e plaats op de Amerikaanse aandelenmarkt sprongen.</p>
<p>MicroStrategy’s Bitcoin-bezittingen hebben vandaag een recordhoogte bereikt, waarbij de Bitcoin-prijzen door de $94.000 heen breken. Op dit moment heeft het in totaal 331.200 Bitcoin in bezit, met een totale aankoopkost van ongeveer $16,5 miljard en een gemiddelde aankoopprijs van $49.874. De huidige totale waarde van de Bitcoin-bezittingen bedraagt $31,39 miljard, met een zwevende winst van meer dan $14,85 miljard.</p>
<h2 id="h2-Markttrends20BTC20bereikte20nieuwe20hoogtepunten20binnen20de20dag20terwijl20Altcoins20over20het20algemeen20daalden792465"><a name="Markttrends: BTC bereikte nieuwe hoogtepunten binnen de dag, terwijl Altcoins over het algemeen daalden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bereikte nieuwe hoogtepunten binnen de dag, terwijl Altcoins over het algemeen daalden</h2><h3 id="h3-Markt20Hotspots896499"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Toonaangevende tokens zoals ACT, PNUT, RIF en GOAT, die in de beginfase de markt leidden, hebben een scherpe daling doorgemaakt en de markt is een fase van post-hype aanpassing ingegaan. Momenteel wachten we nog steeds op de opkomst van het volgende hete onderwerp in de markt en AI-meme blijft een sector die door fondsen wordt begunstigd;</p>
<p>De hond meme FLOKI steeg tegen de trend in. FLOKI is een meme-munt waar Musk tijdens de laatste stierenmarkt vaak over sprak op Twitter, met een marktwaarde van bijna $3 miljard. Momenteel staat FLOKI bijna op zijn all-time high en staat het op de 40e plaats in marktwaarde; In de algehele marktdownturn wordt de opwaartse potentie van FLOKI geschat als beperkt.</p>
<h3 id="h3-Gangbare20Munten636403"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC bereikte ooit een recordhoogte van $94.950, en BTC ETF’s blijven enorme instromen ontvangen gedurende enkele dagen. De vriendelijke cryptomarkt na de verkiezing van Trump is een potentieel groot voordeel voor BTC;</p>
<p>ETH schommelt nog steeds nauw onder $3.100, en zijn prestaties in deze markt zijn relatief traag, wat leidt tot toenemende marktscepsis;</p>
<p>Altcoins vielen over het algemeen, met eerder sterke munten zoals GOAT en PNUT die een daling van 20% binnen een dag meemaakten. De markt wacht op nieuwe verhalen.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20schommelden20Nvidia20daalde20na20het20bekendmaken20van20financieel20rapport673015"><a name="Macro nieuws: Amerikaanse aandelen schommelden, Nvidia daalde na het bekendmaken van financieel rapport" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen schommelden, Nvidia daalde na het bekendmaken van financieel rapport</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,00% steeg naar 5.917,11 punten; De Dow Jones Industrial Average steeg met 0,32% naar 43.408,47 punten; De Nasdaq-index daalde met 0,11% naar 18.966,14 punten. Het referentiepunt voor de 10-jarige Treasury-rente bedraagt 4,41%, terwijl de 2-jarige Treasury-rente, het meest gevoelig voor het rentebeleid van de Federal Reserve, 4,31% bedraagt.</p>
<p>Als ‘s werelds meest waardevolle bedrijf heeft Nvidia’s nieuwste financiële rapport veel aandacht getrokken. Na sluiting van de Amerikaanse aandelenmarkt toonde het derde kwartaalrapport van Nvidia voor het boekjaar 2025 een omzet van $35,08 miljard, een stijging van 94% op jaarbasis; de nettowinst bedroeg $19,309 miljard, een stijging van 109% op jaarbasis. Nvidia CEO Huang Renxun verklaarde dat de Blackwell-chip momenteel in volle productie is. Het product wordt verwacht in de komende kwartalen schaars te zijn. Na de publicatie van het rapport daalde de aandelenkoers van Nvidia ongeveer 5% in de handel na sluitingstijd, waarna de daling zich beperkte tot bijna 2% op het moment van schrijven.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijslaag</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies. 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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen er juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>