RGFnZWxpamtzIG5pZXV3cyB8IERhZ2VsaWprc2UgaW5zdHJvb20gdmFuIEVUSCBFVEYgYmVyZWlrdCBlZW4gcmVjb3JkaG9vZ3RlOyBCaXRjb2luIGRvbWluYW50aWUgZGFhbHQgbmFhciA1Niw3NSU7IFhSUCBpcyBpbiBkZSBhZmdlbG9wZW4gbWFhbmQgbWV0IG1lZXIgZGFuIDMwMCUgZ2VzdGVnZW4=

2024-12-02, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/173311499612.02.png" alt=""></p>
<h2 id="h2-Dagelijkse20samenvatting20Recordinstroom20voor20ETH20ETF20met20meer20dan2033020miljoen20op20n20dag20Aanzienlijke20daling20in20BTCD20met20fondsen20die20naar20altcoins20stromen166815"><a name="Dagelijkse samenvatting: Recordinstroom voor ETH ETF met meer dan $330 miljoen op één dag; Aanzienlijke daling in BTCD met fondsen die naar altcoins stromen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dagelijkse samenvatting: Recordinstroom voor ETH ETF met meer dan $330 miljoen op één dag; Aanzienlijke daling in BTCD met fondsen die naar altcoins stromen</h2><p>Volgens gegevens van Farside Investor, vorige vrijdag, de Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF kende een netto instroom van $320 miljoen. Hiervan was $137 miljoen afkomstig van BlackRock’s IBIT en $106 miljoen van Fidelity’s FBTC.</p>
<p>Op dezelfde dag, de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF zag aanzienlijke instromen van $332 miljoen, waarbij BlackRock’s ETHA $250 miljoen bijdroeg en Fidelity’s FETH $79 miljoen toevoegde.</p>
<h3 id="h3-Bitcoins20marktaandeel20daalt20naar20567520de20marktkapitalisatie20van20Altcoin20stijgt20bijna207020in20november160488"><a name="Bitcoin’s marktaandeel daalt naar 56,75%, de marktkapitalisatie van Altcoin stijgt bijna 70% in november" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin’s marktaandeel daalt naar 56,75%, de marktkapitalisatie van Altcoin stijgt bijna 70% in november</h3><p>Volgens gegevens van TradingView is het marktaandeel van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC.D) gedaald naar 56,75%, vanaf een piek van 61,78% op 21 november, wat een daling van 8,15% markeert.</p>
<p>Bovendien is de totale marktkapitalisatie van cryptocurrencies exclusief Bitcoin sinds 5 november met bijna 70% gestegen, van een dieptepunt van $85,61 miljard naar ongeveer $1,46 biljoen.</p>
<h3 id="h3-Aankomende20Token20Ontgrendelingen2013520Miljoen20JTO20Tokens20Zullen20Op20820December20Ontgrendeld20Worden20Wat20De20Huidige20Uitstaande20Voorraad20Overtreft275245"><a name="Aankomende Token Ontgrendelingen: 135 Miljoen JTO Tokens Zullen Op 8 December Ontgrendeld Worden, Wat De Huidige Uitstaande Voorraad Overtreft" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aankomende Token Ontgrendelingen: 135 Miljoen JTO Tokens Zullen Op 8 December Ontgrendeld Worden, Wat De Huidige Uitstaande Voorraad Overtreft</h3><p>Volgens Tokenomist.ai gegevens staan er volgende week verschillende tokens klaar voor aanzienlijke ontgrendelingen, waaronder Ethena (ENA), die ongeveer 12,86 miljoen tokens zal ontgrendelen op 4 december, wat 0,45% vertegenwoordigt van de huidige uitstaande voorraad, met een waarde van ongeveer $10,58 miljoen; <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA), wat ongeveer 18,53 miljoen tokens zal vrijgeven op 6 december, wat 0,05% uitmaakt van de huidige circulerende voorraad, met een waarde van ongeveer $21,49 miljoen; en Jito (JTO), wat ongeveer 135 miljoen tokens zal vrijgeven op 8 december, wat overeenkomt met 103% van de huidige circulerende voorraad, met een waarde van ongeveer $507 miljoen.</p>
<p>CryptoQuant-analist: <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> stijgt met toegenomen contractposities, vatbaar voor terugslag<br>CryptoQuant-analist Maartunn merkte op sociale media op dat <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> De recente prijsstijging wordt vergezeld door een stijging van de contractposities, wat kan leiden tot een mogelijke terugval. De laatste keer dat een soortgelijke situatie zich voordeed, daalde XRP met 17%. Beleggers wordt geadviseerd om voorzichtig te blijven met de volatiliteit en dienovereenkomstig hun risico’s te beheren.</p>
<p>Volgens de meest recente gegevens van Coinglass hebben de totale bezittingen van XRP in het netwerk de $4 miljard overschreden, momenteel staande op $4,181 miljard (1,747 miljard XRP), met een stijging van 27% in de totale bezittingen in de afgelopen 24 uur, samenvallend met een stijging van 29,2% in de prijs.</p>
<h2 id="h2-Marktanalyse20Gevestigde20Cryptocurrencies20DASH20en20LTC20stijgen20ETH20presteert20sterk478713"><a name="Marktanalyse: Gevestigde Cryptocurrencies DASH en LTC stijgen, ETH presteert sterk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: Gevestigde Cryptocurrencies <a href="/price/dash-dash" target="_blank" class="blog_inner_link">DASH</a> en LTC stijgen, ETH presteert sterk</h2><h3 id="h3-Markt20Highlights346026"><a name="Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Highlights</h3><p>-Gevestigde cryptocurrencies LTC, <a href="/price/dash-dash" rel="nofollow noopener noreferrer" target="_blank">DASH</a>, en ALGO hebben aanzienlijke winsten gezien. Zowel LTC als DASH zijn proof-of-work (PoW) munten die meerdere rondes van bull en bear markten hebben meegemaakt. Er is een opmerkelijke uitstroom van marktfondsen en rotatie tussen sectoren. ALGO, ook een gevestigd openbaar ketenproject, is sinds november met meer dan 300% gestegen, ondanks dat het projectteam geen nieuwe producten of ecosysteemprikkels heeft gelanceerd, wat aangeeft dat de stijging wordt gedreven door marktsentiment.</p>
<p>-HYPE is geëxplodeerd met de aankondiging van de grootste token-airdrop in de geschiedenis van blockchain, waarbij meer dan 30% van de HYPE-tokens aan gebruikers wordt uitgedeeld. Na de lancering is HYPE gestegen van $3 naar boven de $9,50. HYPE is de inheemse token van Hyperliquid, dat zowel een Layer 1 openbare keten als een on-chain gedecentraliseerde beurs (DEX) is.</p>
<h3 id="h3-Markttrends624773"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h3><p>-BTC heeft een sterke prestatie laten zien en brak vanochtend kort door de $98.000. BTCD is de afgelopen week aanzienlijk afgenomen, wat waarschijnlijk aangeeft dat er geld naar altcoins stroomt.</p>
<p>-ETH heeft ook goed gepresteerd en is weer boven de $3.700 uitgekomen. Het ETH/BTC-paar is hersteld van een dieptepunt en afgelopen vrijdag zag de ETH ETF voor het eerst een instroom op één dag die hoger was dan die van de BTC ETF, met $332 miljoen aan instroom, waarmee een nieuw record voor ETH ETF instroom werd gevestigd.</p>
<p>-Altcoins stijgen over het algemeen, waarbij gevestigde munten winst boeken. XRP is sinds november met meer dan 300% gestegen en heeft zijn positie als de op twee na grootste cryptocurrency op basis van marktkapitalisatie herwonnen.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelenmarkten20stijgen20over20de20hele20linie20NonFarm20Data20blijft20een20belangrijk20aandachtspunt124266"><a name="Macro Nieuws: Amerikaanse aandelenmarkten stijgen over de hele linie, Non-Farm Data blijft een belangrijk aandachtspunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelenmarkten stijgen over de hele linie, Non-Farm Data blijft een belangrijk aandachtspunt</h2><p>Afgelopen vrijdag stegen alle drie de belangrijkste Amerikaanse indices gezamenlijk, waarbij de Dow Jones met 0,42% steeg, de S&amp;P 500 met 0,56% steeg, beide stelden nieuwe historische records in, en de Nasdaq steeg met 0,83%. In de afgelopen week zijn alle drie de indices gestegen, waarbij de Dow, S&amp;P 500 en Nasdaq respectievelijk 1,39%, 1,06% en 1,13% hebben gewonnen. Wat betreft de maandelijkse prestaties is de Dow met 7,54% gestegen, is de S&amp;P 500 met 5,73% gestegen, beide markeren de grootste maandelijkse winsten van het jaar, terwijl de Nasdaq 6,21% heeft gewonnen.</p>
<p>De jaarlijkse winsten voor de drie belangrijkste indexen zijn aanzienlijk. Per 29 november is de Nasdaq met 28,02% gestegen, is de S&amp;P 500 met 26,47% gestegen en is de Dow met 19,16% gestegen. Als de S&amp;P 500 blijft stijgen tot het einde van het jaar en een stijging van 29,60% overschrijdt, zal het de grootste stijging sinds de 21e eeuw markeren.</p>
<p>Op korte termijn zal de beslissing van de Federal Reserve over renteverlagingen nog steeds afhangen van gegevens. In het g van geen significante opwaartse risico’s voor korte termijn inflatie, blijven de gegevens over niet-agrarische werkgelegenheid de meest kritieke variabele voor de Fed. Volgend jaar zal de situatie afhangen van de kracht en soepele uitvoering van specifieke beleidsmaatregelen van Trump en hun impact op inflatie, wat een hoog niveau van onzekerheid met zich meebrengt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> icing </strong>, Gate.io-onderzoeker<br><div>Vertaler: Sally<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadviezen. 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>