RGFnZWxpamtzIG5pZXV3cyB8IFdMRCBsZWlkZGUgZGUgQUktc2VjdG9yIG5hYXIgZWVuIGNvbGxlY3RpZXZlIHN0aWpnaW5nLCBBTEdPIHN0ZWVnIG1ldCBtZWVyIGRhbiAyMDAlIGJpbm5lbiBkZSBtYWFuZA==

2024-11-29, 04:53

<p><img src="https://gimg2.gateimg.com/image/article/173285586711.29.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Meer20dan209020van20de20ETHhouders20maakt20winst20de20verkiezingsoverwinning20van20Trump20stimuleert20sterk20de20Bitcoinholdings480159"><a name="Crypto Dagelijks Overzicht: Meer dan 90% van de ETH-houders maakt winst, de verkiezingsoverwinning van Trump stimuleert sterk de Bitcoin-holdings" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Meer dan 90% van de ETH-houders maakt winst, de verkiezingsoverwinning van Trump stimuleert sterk de Bitcoin-holdings</h2><p>Gisteren was de Amerikaanse aandelenmarkt gesloten voor Thanksgiving, en er was geen instroom of uitstroom van fondsen in spot-ETF’s.</p>
<p><strong>IntoTheBlock: 90.8% van de houders van ETH is momenteel winstgevend</strong></p>
<p>IntoTheBlock schreef dat “90,8% van de ETH-houders momenteel winstgevend is, het hoogste niveau sinds juni.</p>
<p>9,2% van de ETH-houders bevindt zich nog steeds in een verliesgevende staat, waarbij hun tokens slechts 2,8% van het totale aanbod uitmaken. Dit geeft aan dat naarmate ETH blijft stijgen, de potentiële verkoopdruk van deze groep een beperkte impact kan hebben.”</p>
<p><strong>CryptoQuant CEO: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> dominantie zal waarschijnlijk niet snel afnemen</strong></p>
<p>CryptoQuant CEO Ki Young Ju verklaarde in een bericht dat gezien zijn groeisnelheid, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De dominantie van ‘s werelds grootste cryptocurrency zal waarschijnlijk niet snel afnemen. Tijdens de stijging van 37% in de marktkapitalisatie van Bitcoin, stegen de grote Altcoins met 16%, terwijl de kleine en middelgrote Altcoins met 10% stegen. De enige keer dat de marktkapitalisatie van kleine en middelgrote Altcoins de groei van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> overtrof, was tijdens het Meme-seizoen in april.</p>
<p><strong>Sinds de verkiezingsoverwinning van Trump is het openstaande belang in Bitcoin-futures aanzienlijk toegenomen, met een waarde van meer dan $60 miljard.</strong></p>
<p>Volgens The Block is sinds Trump’s overwinning op 5 november de open rente in Bitcoin-futures aanzienlijk gestegen, van $39 miljard op 5 november tot de huidige $60,9 miljard, wat wijst op een toename van de handelsactiviteit en marktspeculatie. Maar analisten geloven dat hefboomhandel geen risico zal lopen op een onmiddellijke marktcorrectie.</p>
<p>Analisten zeggen dat de toename van openstaande futures een natuurlijke groei lijkt te zijn, gedreven door verwachtingen van toekomstige prijsstijgingen. Het opbouwen van leverage is een veelgebruikt instrument dat door handelaren, inclusief instellingen, wordt gebruikt om zich voor te bereiden op verwachte prijstrends.</p>
<p>Het wees er ook op dat het aantal open futures is afgenomen, met name op het niveau rond de $94.000, waarbij een groot aantal uitstaande orders worden uitgevoerd. En het verklaarde dat het van mening is dat er geen abnormaliteit is in de recente opeenhoping van hefboomwerking, en de prijs backtesten in het gebied van $93.000 is een normale correctie.</p>
<h2 id="h2-Markttrends20De20AIsector20steeg20collectief20waarbij20de20gevestigde20openbare20keten20ALGO20een20maandelijkse20stijging20van20meer20dan2020020doormaakte283944"><a name="Markttrends: De AI-sector steeg collectief, waarbij de gevestigde openbare keten ALGO een maandelijkse stijging van meer dan 200% doormaakte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De AI-sector steeg collectief, waarbij de gevestigde openbare keten ALGO een maandelijkse stijging van meer dan 200% doormaakte</h2><h3 id="h3-Markt20Hotspots669775"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De AI-sector kende een collectieve stijging van WLD, FET, THETA en meer. De Worldcoin App heeft meer dan 17 miljoen wereldwijde irisverificatiegebruikers, waarbij WLD momenteel een circulerende marktkapitalisatie heeft van $1,8 miljard en een totale circulerende marktkapitalisatie van $26 miljard. Daarnaast worden dagelijks tientallen miljoenen dollars aan tokens ontgrendeld; Het blijft nog te bezien in hoeverre WLD kan stijgen met de steun van het AI-verhaal en een lage circulatie met een hoge FDV;</p>
<p>De goed gevestigde openbare keten ALGO is met 20% gestegen, waarbij ALGO sinds begin november met meer dan 200% is gestegen; Het ALGO-team is opgericht in 2017 en de token is uitgegeven in 2019, met een historische hoogste prijs van $3,44. Momenteel is de prijs met 90% gedaald ten opzichte van het historische hoogtepunt; In de hete plek van het openbare ketenspoor op de markt behaalde ALGO een 20-voudige stijging in de vorige bullmarkt, met een huidige circulerende marktkapitalisatie van $2,85 miljard en het opwaartse potentieel wordt geschat als beperkt.</p>
<h3 id="h3-Mainstream20Munten651578"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC consolideert nauw en wacht nog steeds op een kans om boven de $96.000 uit te breken, aangezien er geen kapitaalinstroom is in de BTC ETF tijdens de Thanksgiving-vakantie op de Amerikaanse aandelenmarkt;</p>
<p>ETH had een lichte daling, maar bleef boven $3.550 en kreeg sterke ondersteuning in het maandelijkse middenbereik, wat wijst op een veelbelovende toekomst voor ETH;</p>
<p>Altcoins zijn over het algemeen gestegen, maar de hotspots zijn verspreid en de AI-sector blijft een van de belangrijkste verhalen op de markt.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelenmarkt20gesloten20voor20Thanksgiving20geen20bijgewerkte20gegevens20of20meningen20op20de20markt438390"><a name="Macro nieuws: Amerikaanse aandelenmarkt gesloten voor Thanksgiving, geen bijgewerkte gegevens of meningen op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelenmarkt gesloten voor Thanksgiving, geen bijgewerkte gegevens of meningen op de markt</h2><div class="blog-details-info"><br><div>Auteur:<strong>Icing</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>