RGFnZWxpamtzIE5pZXV3cyB8IEJUQyBrZWVydCB0ZXJ1ZyBib3ZlbiAkOTguMDAwLCBQSEEgc3Rpamd0IG1ldCA3MCUgYmlubmVuIGVlbiBkYWcgZW4gbGVpZHQgZGUgbWFya3Q=

2024-12-25, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/173509771512.25.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20hebben20420opeenvolgende20dagen20aanzienlijke20uitstroom20ervaren20met20Lido20TVL20als20leider20in20het20DeFiecosysteem624715"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s hebben 4 opeenvolgende dagen aanzienlijke uitstroom ervaren, met Lido TVL als leider in het DeFi-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s hebben 4 opeenvolgende dagen aanzienlijke uitstroom ervaren, met Lido TVL als leider in het DeFi-ecosysteem</h2><p>Volgens de gegevens van Farside Investors was er gisteren een nettostroom vanuit de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De netto-instroom van Amerikaanse spot ETF’s bedroeg $340 miljoen. BlackRock IBIT had een netto uitstroom van $190 miljoen, Fidelity FBTC had een netto uitstroom van $83 miljoen en Ark ARKB had een netto uitstroom van $75 miljoen.</p>
<p>Gisteren was er een nettostroom van US <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De instroom van spot ETF bedroeg $54 miljoen. De instroom van BlackRock’s ETHA was $44,8 miljoen, en de instroom van Fidelity’s FETH was $3,5 miljoen.</p>
<p><strong>Gegevens: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en Altcoins herstelden zich goed voor Kerstmis, en de voortdurende accumulatie van de Whale Wallet zal de bullmarkt voortzetten</strong></p>
<p>Volgens de gegevens van Santiment zijn Bitcoin en Altcoins goed hersteld vóór Kerstmis, waarbij de prijzen van Bitcoin zijn gestegen tot $99.000. Huidige verdeling van Bitcoin wallet-adressen:</p>
<p>-In bezit van 0-0,1 BTC: 50,17 miljoen;<br>-In bezit van 0,1-10 BTC: 4,31 miljoen;<br>-In bezit van 10-1.000 BTC: 150.130;<br>-In bezit van meer dan 1.000 BTC: 2.050;</p>
<p>Analyse suggereert dat zolang het aantal grote en whale wallets (de laatste twee groepen) blijft groeien en de accumulatietrend vanaf 2024 aanhoudt, de kans groot is dat de bullmarkt zal aanhouden.</p>
<p><strong>Het totale nettostortingen van <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> en Lido overschreed voor het eerst $70 miljard, goed voor 45,5% van de totale stortingen van de top 20 DeFi Apps</strong></p>
<p>Volgens gegevens van TokenTerminal overtroffen de totale netto stortingen van het uitleenprotocol <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> en het liquiditeitsstakingprotocol Lido voor het eerst $70 miljard in december (momenteel terugglen tot $67,37 miljard). Daarvan stond Aave op de eerste plaats met $34,3 miljard, gevolgd door Lido met $33,1 miljard. De twee belangrijkste protocollen samen vertegenwoordigen 45,5% van de totale stortingen in de top 20 DeFi-toepassingen.</p>
<p>Qua lock-up volume (TVL) leidt Lido het DeFi-ecosysteem met $33,8 miljard, terwijl Aave op de tweede plaats staat met $20,6 miljard. In de afgelopen 30 dagen is de omzet van Aave met 27,5% gestegen tot $12,5 miljoen, terwijl de omzet van Lido met 24% is gestegen tot $9,6 miljoen. Het totale lock-up volume van DeFi in 2024 is met 107% gestegen tot $185 miljard, en op 16 december overtrof het kortstondig $212 miljard. (CryptoSlate)</p>
<p><strong>In de afgelopen week bedroeg de gemiddelde stijging van de top NFT’s 6,4%, wat beter presteerde dan het gemiddelde resultaat van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> bij -8,6%</strong></p>
<p>Volgens CryptoSlate laat de NFT Price Floor data zien dat de gemiddelde stijging van de top tien NFT-series in de afgelopen 7 dagen 6,4% heeft bereikt, aanzienlijk beter dan de gemiddelde prestatie van de cryptomarkt van -8,6%. Onder hen leidde Space Doodles de weg met een stijging van 44,7%, gevolgd door Lil Pudgys en Doodles met respectievelijk 35,1% en 34,8%. Azuki en Pudgy Penguins registreerden ook een positieve groei van meer dan 14%.</p>
<p>Echter blijft de algehele handelsactiviteit op de markt zwak. De wekelijkse handelsvolume van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> NFT was $129 miljoen, een daling van 28,5% vergeleken met de vorige periode; Het transactievolume van NFT’s op de Bitcoin en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De omzet van chains was respectievelijk $29,3 miljoen en $24,3 miljoen, een daling van 46% en 38,5% op maandbasis. Er is nog steeds een aanzienlijk verschil tussen de mainstream NFT-series en historische hoogtepunten: CryptoPunks is met 65% gedaald vanaf zijn hoogtepunt van 114 ETH in oktober 2021, BAYC is met 87% gedaald vanaf zijn hoogtepunt van 128 ETH in april 2022, en MAYC is met 91% gedaald vanaf zijn hoogtepunt.</p>
<h2 id="h2-Markttrends20PHA20steeg20met207020binnen20een20dag20en20leidde20de20markt20terwijl20Grayscaleconcepttokens20zoals20BAT20en20LPT20stegen692625"><a name="Markttrends: PHA steeg met 70% binnen een dag en leidde de markt, terwijl Grayscale-concepttokens zoals BAT en LPT stegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: PHA steeg met 70% binnen een dag en leidde de markt, terwijl Grayscale-concepttokens zoals BAT en LPT stegen</h2><h3 id="h3-Markt20Hotspots429315"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De AI-concepttoken PHA steeg fors en leidde de markt met een intraday stijging van meer dan 70%; Hoewel PHA gisteren steeg, daalde het nog steeds meer dan 80% vanaf zijn historische hoogtepunt van $1,24; In de meest populaire AI-markt van deze ronde heeft PHA momenteel een marktkapitalisatie van $170 miljoen. Vergeleken met toonaangevende protocollen en AI-concept-mememunten in dezelfde markt, heeft de populaire PHA mogelijk nog steeds veel potentieel;</p>
<p>Het NFT-project Pugdy Penguins-token PENGU is bijna 40% gestegen, met een huidige circulerende marktkapitalisatie van $2,4 miljard, en staat op de 56e plaats in de hele markt; De huidige enorme marktkapitalisatie van PENGU en het gebrek aan enig gebruik of consumptiescenario lijken erop te wijzen dat de opwaartse trend van PENGU waarschijnlijk niet zal aanhouden;</p>
<p>De conceptmunten BAT en LPT gelanceerd door Grayscale stegen. Eerder verdubbelde de prijs van een andere token ZEN gelanceerd door Grayscale binnen twee dagen, wat de stijging van andere tokens met een lage marktkapitalisatie in de Grayscale-portefeuille stimuleerde; De holdings van Grayscale BAT en LPT zijn niet significant toegenomen en de recente stijging is duidelijk te wijten aan marktgedrag in plaats van aankopen van Grayscale.</p>
<h3 id="h3-Mainstream20Coins319882"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>BTC keerde terug boven $98.000 en kreeg ondersteuning onder het dagelijkse gemiddelde. Op middellange tot lange termijn blijft BTC tegen een lage prijs;</p>
<p>ETH vertoonde een sterke prestatie, en de grote instroom van ETH ETF’s van BlackRock heeft de huidige prijs van ETH ondersteund. Alleen wanneer ETH sterk blijft, kan het een bullmarkt voor Altcoins teweegbrengen;</p>
<p>Altcoins stijgen over het algemeen, markthotspots zijn verspreid en er zijn meer mogelijkheden op de keten.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20collectief20hoger20af20en20de20Amerikaanse20aandelenmarkt20is20vandaag20gesloten20vanwege20Kerstmis802280"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices sloten collectief hoger af en de Amerikaanse aandelenmarkt is vandaag gesloten vanwege Kerstmis." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices sloten collectief hoger af en de Amerikaanse aandelenmarkt is vandaag gesloten vanwege Kerstmis.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten collectief hoger, waarbij de S&amp;P 500 index steeg met 1,10% tot 6.040,04 punten; De Dow Jones Industrial Average steeg met 0,91% tot 43.297,03 punten; De Nasdaq-index steeg met 1,35% en eindigde op 20.031,13 punten. Het referentiepunt van 10-jaars Treasury-opbrengst is 4,59%, terwijl de 2-jaars Treasury-opbrengst, die het meest gevoelig is voor het rentebeleid van de Federal Reserve, 4,29% bedraagt.</p>
<p>Op dit moment richten investeerders zich op de voortgang van de inauguratieceremonie van het Witte Huis van de Amerikaanse president-elect Trump op 20 januari. Analisten zeggen dat de volgorde van de uitvoering van het beleid na de inauguratie van Trump momenteel onduidelijk is en dat er sterke onzekerheid is over de toekomst.</p>
<p>Daarnaast zal het rentebeleidscomité van de Fed nieuwe stemgerechtigde leden verwelkomen, waaronder verschillende havikachtige functionarissen. Tegelijkertijd heeft de huidige opleving van zorgen over inflatie een nieuwe laag complexiteit toegevoegd aan het besluitvormingsproces van de Fed.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>IJsing</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 investeringen 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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>