RGFnZWxpamtzIG5pZXV3cyB8IERlIG1hcmt0IGlzIG92ZXIgaGV0IGFsZ2VtZWVuIGJlYXJpc2ggZW4gUEhBIGxlaWRkZSBkZSBBSS1zZWN0b3Igb20gYW5kZXJlbiB0ZSBvdmVydHJlZmZlbg==

2024-12-30, 04:22

<p><img src="https://gimg2.gateimg.com/image/article/173553234312.30.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Het20aandeel20van20lange20termijn20ETHhouders20neemt20toe20en20SUI20staat20op20het20punt20om20meer20dan2020020miljoen20aan20tokens20vrij20te20geven372139"><a name="Crypto Dagelijkse Samenvatting: Het aandeel van lange termijn ETH-houders neemt toe, en SUI staat op het punt om meer dan $200 miljoen aan tokens vrij te geven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Het aandeel van lange termijn ETH-houders neemt toe, en SUI staat op het punt om meer dan $200 miljoen aan tokens vrij te geven</h2><p>Volgens gegevens van Farside Investors, de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had afgelopen vrijdag een nettouitstroom van $287 miljoen. BlackRock IBIT had een instroom van $79,4 miljoen, Fidelity FBTC had een nettouitstroom van $208 miljoen en Ark ARKB had een uitstroom van $112 miljoen.</p>
<p>De VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF zag afgelopen vrijdag een nettostroom van $47,7 miljoen. BlackRock ETHA zag een instroom van $20,2 miljoen, en Fidelity FETH zag een instroom van $27,5 miljoen.</p>
<p><strong>IntoTheBlock: Het aandeel langetermijnhouders van ETH is toegenomen, terwijl het aandeel langetermijnhouders van BTC is afgenomen</strong></p>
<p>IntoTheBlock heeft de trend van het percentage langetermijnhouders van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in het afgelopen jaar op het X-platform bekendgemaakt. Uit de gegevens blijkt dat het percentage langetermijnhouders van Bitcoin daalt, terwijl het percentage langetermijnhouders van Ethereum blijft stijgen en Bitcoin aan het begin van het jaar heeft ingehaald.</p>
<p>Volgens de huidige gegevens van deze indicator is het percentage langetermijnhouders van Bitcoin 62,31% en het percentage langetermijnhouders van Ethereum 75,06%.</p>
<p><strong>De huidige mainstream CEX en DEX financieringspercentages tonen aan dat de markt over het algemeen bearish is</strong></p>
<p>Volgens gegevens van Coinglass, toen Bitcoin vanochtend daalde tot $93,009, laten de huidige hoofdstroom CEX- en DEX-financieringspercentages zien dat de markt over het algemeen bearish is. De specifieke financieringspercentages voor belangrijke valuta’s worden weergegeven in de onderstaande figuur.</p>
<p>Let op: Wanneer de financieringsrente 0,01% is, betekent dit dat dit de marktbasisrente is. Wanneer de financieringsrente hoger is dan 0,01%, betekent dit dat de markt over het algemeen bullish is. Wanneer de financieringsrente lager is dan 0,005%, betekent dit dat de markt over het algemeen bearish is.</p>
<p><strong>Overzicht van het ontgrendelen van gegevens deze week: OP, SUI, ZETA en andere tokens zullen in grote hoeveelheden worden ontgrendeld</strong></p>
<p>Volgens Token Unlocks-gegevens zullen OP, SUI, ZETA en andere tokens deze week grote hoeveelheden ontgrendeling ontvangen, waaronder:</p>
<p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> (OP) zal naar verwachting ongeveer 31,34 miljoen tokens ontgrendelen om 8:00 uur op 31 december, Beijing-tijd, met een verhouding van 2,32% tot de huidige circulerende voorraad en een waarde van ongeveer $57,04 miljoen;</p>
<p>Sui (SUI) zal ongeveer 64,19 miljoen tokens ontgrendelen om 8:00 op 1 januari 2025, Beijing-tijd, met een verhouding van 2,19% ten opzichte van de huidige circulerende voorraad en een waarde van ongeveer $263 miljoen;</p>
<p>ZetaChain (ZETA) zal ongeveer 53,89 miljoen tokens ontgrendelen om 8:00 op 1 januari 2025, Beijing-tijd, met een verhouding van 9,35% van de huidige circulerende voorraad en een waarde van ongeveer $31,18 miljoen;</p>
<p>Kaspa (KAS) zal ongeveer 182 miljoen tokens ontgrendelen om 8:00 uur op 6 januari 2025, Beijing tijd, met een verhouding van 0,72% ten opzichte van de huidige omloopvoorraad en een waarde van ongeveer $21,31 miljoen.</p>
<h2 id="h2-Markttrends20AGLD20steeg20met204020binnen20een20dag20en20PHA20is20in20de20afgelopen20720dagen20met20meer20dan2050020gestegen573963"><a name="Markttrends: AGLD steeg met 40% binnen een dag, en PHA is in de afgelopen 7 dagen met meer dan 500% gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: AGLD steeg met 40% binnen een dag, en PHA is in de afgelopen 7 dagen met meer dan 500% gestegen</h2><h3 id="h3-Markt20Hotspots90680"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>In de AI-sector hebben AI16Z, ARC, VIRTUAL, AIXBT, enz. goede winsten behaald; AI16Z heeft een nieuwe whitepaper gelanceerd, en ai16z-gerelateerde tokens zijn ook een veelbesproken onderwerp op de recente markt; PHA blijft scherp stijgen, met een stijging van meer dan 500% in de afgelopen zeven dagen. Phala Network is een op blockchain gebaseerd privacy-rekenplatform dat Trusted ution Environment (TEE) technologie gebruikt om gegevensprivacybescherming te bieden voor gedecentraliseerde toepassingen;</p>
<p>AGLD steeg overdag met 40%. AGLD is de governance- en gastoken van het Adventure Layer-platform. Adventure Layer is toegewijd aan het creëren van exclusieve Layer2-oplossingen voor on-chain games (Fully Onchain Games, FOCG). AGLD is oorspronkelijk afkomstig van het Loot NFT-project. Met de uitbreiding van het ecosysteem is het nu uitgegroeid tot een ecosysteemtoken dat volledige ondersteuning biedt voor de ontwikkeling van on-chain games en een kernonderdeel is geworden van Adventure Layer; AGLD heeft momenteel een circulerende marktkapitalisatie van $200 miljoen en staat op de eerste plaats in de hele markt, nummer 309.</p>
<h2 id="h2-Gangbare20Munten86943"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h2><p>BTC schommelde en daalde, en viel vanochtend onder de $93.000. Afgaande op de AHR999-indicator, de huidige <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC-prijs</a> ligt iets hoger dan de vaste investeringsprijs. De daling is een goede gelegenheid om te kopen;</p>
<p>De prijs van ETH is relatief sterk gebleven en blijft boven de $3.400. De voortdurende nettostroom van ETH ETF in de afgelopen week heeft de prijs van ETH ondersteund;</p>
<p>Altcoins vielen over het algemeen, markthotspots roteerden erg snel en alleen de AI-sector heeft een langetermijnverhaal.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20sloten20collectief20lager20de20Federal20Reserve20kan20het20verlagen20van20de20rente20in20202520vertragen775937"><a name="Macro Nieuws: Amerikaanse aandelen sloten collectief lager, de Federal Reserve kan het verlagen van de rente in 2025 vertragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen sloten collectief lager, de Federal Reserve kan het verlagen van de rente in 2025 vertragen</h2><p>Afgelopen vrijdag sloten de drie belangrijkste Amerikaanse aandelenindices gezamenlijk lager, waarbij de S&amp;P 500-index met 1,11% daalde tot 5.970,84 punten; de Dow Jones-index met 0,77% daalde tot 42.992,21 punten; en de Nasdaq-index met 1,49% daalde tot 19.722,03 punten. Het referentiepunt voor de 10-jarige Amerikaanse schatkistrendement bedraagt 4,62% en het rendement van de 2-jarige Amerikaanse schatkist, dat het meest gevoelig is voor het rentebeleid van de Fed, bedraagt 4,31%.</p>
<p>Aandelen in de VS presteren doorgaans goed in de laatste vijf handelsdagen van december en de eerste twee handelsdagen van januari. Dit fenomeen staat bekend als de ‘Santa Claus-markt’. Die rally heeft de S&amp;P 500 gemiddeld met 1,3% doen stijgen sinds 1969, volgens de Stock Trader’s Almanac. Hoelang het opwaartse momentum zal duren, hangt af van verschillende factoren. De maandelijkse werkgelegenheidsgegevens van de VS, die op 10 januari 2025 zullen worden vrijgegeven, zouden beleggers een nieuw perspectief moeten geven op de gezondheid en kracht van de Amerikaanse economie. De banengroei in de VS herstelde zich in november 2024 na tegenslagen veroorzaakt door orkanen en stakingen eerder in 2024. Bovendien zal de kracht van de markt opnieuw worden getest wanneer Amerikaanse bedrijven nieuwe kwartaalresultaten bekendmaken.</p>
<p>Volgens marktvisies heeft de Federal Reserve gesuggereerd dat het het tempo van renteverlagingen in 2025 zal vertragen. Gezien de huidige situatie wordt verwacht dat de Fed de leenkosten zal blijven verlagen tot juni 2025. Als Trump na zijn aantreden losse begrotingsbeleid initieert, de controle versoepelt, immigratiecontroles aanscherpt en uitgebreide tarieven oplegt aan belangrijke handelspartners, zal de stijgende inflatiedruk in de Verenigde Staten de Federal Reserve dwingen om de koers van het monetair beleid te wijzigen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijs</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle beleggingen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>