RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBkYWFsZGUgb25kZXIgJDk0LjAwMCwgTWVtZSBlbiBBSSBibGlqdmVuIGJlbGFuZ3JpamtlIHZlcmhhbGVuIHZvb3IgZGUgdG9la29tc3Q=

2024-12-23, 04:34

<p><img src="https://gimg2.gateimg.com/image/article/173492829112.23.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20bleef20afgelopen20vrijdag20grote20uitstromen20ervaren20met20BlackRock20die20zeldzame20gegevens20toont20over20uitstromen429934"><a name="Crypto Dagelijkse Samenvatting: BTC ETF bleef afgelopen vrijdag grote uitstromen ervaren, met BlackRock die zeldzame gegevens toont over uitstromen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF bleef afgelopen vrijdag grote uitstromen ervaren, met BlackRock die zeldzame gegevens toont over uitstromen</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 a netto-uitstroom van $277 miljoen afgelopen vrijdag. BlackRock IBIT had een netto-uitstroom van $72.7 miljoen, Fidelity FBTC had een netto-uitstroom van $71.9 miljoen en Ark ARKB had een netto-uitstroom van $87 miljoen.</p>
<p>Afgelopen vrijdag, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had een nettostroom van $75,1 miljoen. De uitstroom van BlackRock’s ETHA was $103 miljoen, en de instroom van Fidelity’s FETH was $13 miljoen.</p>
<p><strong>Gegevens: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het stakingspercentage heeft 27,9% bereikt en het marktaandeel van Lido heeft 28,36% bereikt</strong></p>
<p>Volgens Dune Analytics-gegevens bedraagt het totale bedrag aan <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> beacon-chain staking bereikte 34.213.997 ETH, waarbij stakende ETH goed is voor 27,9% van het totale aanbod. Het marktaandeel van Lido in het liquiditeitsstakingprotocol bereikte 28,36%. Bovendien zag ETH een nettotoename van 16.047.943 ETH na de Shanghai-upgrade.</p>
<p><strong>Deze week ontgrendelingsgegevenslijst: IMX, DBX en andere tokens zullen grote ontgrendelingsbedragen ontvangen</strong></p>
<p>Volgens gegevens van Token Unlocks zullen tokens zoals IMX en DBX deze week grote unlocks ontvangen, waaronder:</p>
<p>-Ethena (ENA) zal naar verwachting ongeveer 12,86 miljoen tokens ontgrendelen om 15:00 uur Peking-tijd op 25 december, met een verhouding van 0,44% ten opzichte van de huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> en een waarde van ongeveer $13,22 miljoen;</p>
<ul>
<li><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>(ADA) zal op 26 december om 8:00 uur Beijing-tijd ongeveer 18,53 miljoen tokens ontgrendelen, met een ratio van 0,05% ten opzichte van de huidige circulatie en een waarde van ongeveer $16,3 miljoen;</li></ul>
<p>-Immutable (IMX) zal naar verwachting ongeveer 24,52 miljoen tokens ontgrendelen om 8:00 uur Beijing tijd op 27 december, met een huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> ratio van 1,45% en een waarde van ongeveer $32,12 miljoen;</p>
<ul>
<li><a href="/price/beldex-bdx" rel="nofollow noopener noreferrer" target="_blank">Beldex</a> (DBX) zal naar verwachting rond 8:00 uur Beijing-tijd op 30 december ongeveer 330 miljoen tokens vrijgeven, met een huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> ratio van 4,78% en een waarde van ongeveer $25,46 miljoen;</li></ul>
<p><strong><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is in december 6 keer gesloten en 5 keer gesloten in zijn geschiedenis, en is in de afgelopen 5 jaar 4 keer uit bullmarkten gekomen na Kerstmis</strong></p>
<p>Volgens gegevens van Coinglass zijn van de 11 “december” markttrends in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In de geschiedenis waren er 6 dalende sluitingen en 5 stijgende sluitingen. De grootste maandelijkse stijging vond plaats in december 2020, toen de maandelijkse stijging 46,92% bedroeg. De grootste maandelijkse daling vond plaats in december 2013, toen de maandelijkse daling 34,81% bedroeg.</p>
<p>Het is echter de moeite waard om op te merken dat elke keer in de geschiedenis, wanneer <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in september sloot, het in staat was om te stijgen tot het einde van het jaar (voortdurend stijgend in oktober, november en december), en Bitcoin sloot dit jaar met 7,35% in september, waarmee een record werd gevestigd voor de beste septemberprestatie in de geschiedenis.</p>
<p>Bovendien, of omdat het eerste kwartaal meestal het kwartaal is waarin vermogensbeheerders de jaarlijkse fondstoewijzing uitvoeren, zijn er in de afgelopen 5 jaar (2019-2023) 4 jaar geweest waarin stierenmarkten zijn ontstaan tijdens Kerstmis, en slechts één keer in 2021 waarin een daling begon na Kerstmis (de vorige stierenpiek).</p>
<h2 id="h2-Markttrends20PNUT20en20GOAT20zijn20aanzienlijk20hersteld20van20de20bodem20terwijl20Meme20en20AI20de20belangrijkste20verhalen20van20de20toekomst20blijven242112"><a name="Markttrends: PNUT en GOAT zijn aanzienlijk hersteld van de bodem, terwijl Meme en AI de belangrijkste verhalen van de toekomst blijven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: PNUT en GOAT zijn aanzienlijk hersteld van de bodem, terwijl Meme en AI de belangrijkste verhalen van de toekomst blijven</h2><h3 id="h3-Markt20Hotspots618619"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><ul>
<li>De Meme sector kende een aanzienlijk herstel vanaf de bodem, inclusief PNUT en GOAT, beide nieuwe tokens in deze fase van markttrends. PNUT profiteerde van de steun van Musk en Trump voor en na de Amerikaanse verkiezingen, terwijl GOAT de toonaangevende token was op de AI meme markt in de beginfase;</li></ul>
<p>Veel Trump-concept tokens op de chain zijn gestegen, maar het handelsvolume is niet groot. De markt is van mening dat vóór en na de inauguratie van Trump op 20 januari volgend jaar, het een golf van de Altcoin-markt kan stimuleren, en de Trump-concept meme-coins die op de chain verschijnen, kunnen een vroeg hinderlaag zijn.</p>
<h3 id="h3-Mainstream20Munten635959"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>-BTC daalde aanzienlijk onder de $93.000 afgelopen vrijdagavond, herstelde tot ongeveer $99.500 op zaterdag en daalde vervolgens opnieuw. Momenteel consolideert het rond de $94.000. Afgelopen donderdag zag BTC ETF een record dagelijkse uitstroom en de markt kan op korte termijn blijven aanpassen;</p>
<p>-ETH bleef in lijn met de markt op en neer gaan zonder zelfstandige trends. In deze stijging heeft ETH nog steeds geen doorbraak bereikt van het historische hoogtepunt van $4.800;</p>
<p>-Altcoins vielen over het algemeen, en de meme- en AI-sectoren kwamen beide tot stilstand. Op dit moment zijn deze twee sectoren nog steeds de belangrijkste marktverhalen voor de toekomst.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindices20stegen20met20meer20dan20120wat20wijst20op20een20voortdurende20trend20naar20een20ruim20monetair20beleid854723"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices stegen met meer dan 1%, wat wijst op een voortdurende trend naar een ruim monetair beleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices stegen met meer dan 1%, wat wijst op een voortdurende trend naar een ruim monetair beleid</h2><p>De drie belangrijkste Amerikaanse aandelenindices stegen allemaal meer dan 1%, waarbij de S &amp; P 500-index met 1,09% steeg tot 5.930,85 punten; De Dow Jones Industrial Average steeg met 1,18% tot 42.840,26 punten; De Nasdaq-index steeg met 1,03% tot 19.572,60 punten. Het referentiepunt voor de 10-jarige schatkistrente bedraagt 4,52%, terwijl de 2-jarige schatkistrente, het meest gevoelig voor het Fed-beleidspercentage, 4,30% bedraagt.</p>
<p>Vorige week heeft de Federal Reserve zoals gepland de rente verlaagd, wat theoretisch positief zou moeten zijn voor de Amerikaanse aandelenmarkt. Echter, na de aankondiging van de renteverlaging was de marktreactie intens, met aanzienlijk stijgende Amerikaanse obligatierendementen, een stijgende Amerikaanse dollar en de drie belangrijkste Amerikaanse aandelenindexen die tegenslagen te verduren kregen. De negatieve reactie op de markt is geworteld in de havikachtige houding van de Federal Reserve ten opzichte van de toekomstige koers van renteverlagingen. Met andere woorden, de markt had de verwachting van een renteverlaging van 25 basispunten al verwerkt vóór de vergadering, en investeerders zijn meer bezorgd over hoe de renteverlaging zal worden uitgevoerd in 2025.</p>
<p>Het puntendiagram van december toont aan dat de meeste ambtenaren geneigd zijn om de rentetarieven in 2025 te blijven verlagen, maar het aantal renteverlagingen is gedaald van 4 in september tot 2. De afgelopen maanden is de Amerikaanse economie veerkrachtig gebleven, blijft de inflatie plakkerig en kan de komende nieuwe regering inflatie-uitdagingen met zich meebrengen. Tegen deze achtergrond bestaat nog steeds de neiging van de Federal Reserve om het monetaire beleid verder te versoepelen, maar voorzichtigheid en geduld zijn nodig in deze fase.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Geglazuurde</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 enkele beleggingsaanbeveling. Alle investeringen 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>