RGFnZWxpamtzIG5pZXV3cyB8IEJUQyB2aWVsIGJpbm5lbiBlZW4gc21hbCBiZXJlaWssIHRlcndpamwgZGUgQUkgTWVtZSBzZWN0b3IgY29sbGVjdGllZiBzdGVlZw==

2024-12-31, 04:01

<p><img src="https://gimg2.gateimg.com/image/article/173561732812.31.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20samenvatting20AIconcept20mememunten20stegen20over20het20algemeen20en20grote20walvissen20vergrootten20opnieuw20hun20belang20in20AIXBT56735"><a name="Crypto Dagelijkse samenvatting: AI-concept meme-munten stegen over het algemeen, en grote walvissen vergrootten opnieuw hun belang in AIXBT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse samenvatting: AI-concept meme-munten stegen over het algemeen, en grote walvissen vergrootten opnieuw hun belang in AIXBT</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 gisteren een netto uitstroom van $378 miljoen. Fidelity FBTC had een netto uitstroom van $154 miljoen, Grayscale GBTC had een netto uitstroom van $134 miljoen en de BlackRock IBIT-gegevens zijn nog niet bijgewerkt.</p>
<p>Gisteren heeft de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had een netto-uitstroom van $55,5 miljoen. Fidelity FETH had een uitstroom van $20,4 miljoen, Grayscale ETHE had een uitstroom van $17,4 miljoen, en de gegevens van BlackRock’s ETHA zijn nog niet bijgewerkt.</p>
<p><strong>Analist: De inauguratie van Trump op 20 januari kan een signaal zijn voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> om het dieptepunt te bereiken</strong></p>
<p>CoinDesk-analist James Van Straten plaatste dat de Amerikaanse minister van Financiën Janet Yellen een brief heeft gestuurd naar de leiders van het Congres waarin staat dat het ministerie van Financiën verwacht dat de Verenigde Staten het schuldenplafond al op 14-23 januari 2025 zullen bereiken, en mogelijk “speciale maatregelen” moeten nemen om te voorkomen dat de federale overheid in gebreke blijft.</p>
<p>Het verhogen van het schuldenplafond is historisch gezien een negatief teken voor Bitcoin, en in de afgelopen vijf van dergelijke glen is de Bitcoin gedaald of ondergepresteerd in de dagen die volgden.</p>
<p>Sinds het laagste punt van de cyclus in november 2022 beweegt Bitcoin in lijn met de vorige twee cycli. De cycli van 2018-2022 en 2015-2018 kenden beide significante retracements op dit punt in de cyclus. De inauguratie van Trump op 20 januari zou kunnen dienen als een bodemsignaal voor Bitcoin.</p>
<p><strong>Walvissen/instanties die $49,89 miljoen aan winst hebben geaccumuleerd uit <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> en UNI hebben opnieuw hun bezit van AIXBT verhoogd met $1,3 miljoen</strong></p>
<p>Volgens monitoring door on-chain data-analist Ember, kopen walvissen/instituten die $49.89 miljoen aan <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> en UNI hebben verzameld nog steeds AIXBT via Wintermute, en ontvingen ze 3 uur geleden nog steeds 2.61 miljoen AIXBT (ongeveer $1.3 miljoen) van het Wintermute adres.</p>
<p>Sinds 4 december heeft deze walvis/instelling in totaal 6,1 miljoen USDC overgemaakt naar Wintermute, en vervolgens 12,99 miljoen AIXBT (ongeveer $4,26 miljoen), 31,25 miljoen NFTXBT (ongeveer $500.000), enz. van het Wintermute-adres ontvangen. Daarvan heeft AIXBT nu een drijvende winst van $2,15 miljoen (+50%).</p>
<p><strong>AI-concept-mememunten stijgen over het algemeen, en ELIZA steeg met meer dan 67% in 24 uur.</strong></p>
<p>Volgens <a href="https://t.me/GMGN_sol_bot?start=i_m4TE56o8" rel="nofollow noopener noreferrer" target="_blank">GMGN</a> Gegevens, AI-concept Meme-tokens zijn over het algemeen gestegen, waaronder:</p>
<p>-ELIZA steeg in 24 uur met 67,3%, met een marktkapitalisatie van $136 miljoen;</p>
<p>-ai16z steeg met 39.23% in 24 uur, en de marktkapitalisatie is nu $1.86 miljard;</p>
<p>-FARTCOIN steeg met 58,42% in 24 uur, en de marktkapitalisatie is nu $967 miljoen;</p>
<p>-ZEREBRO steeg met 41,05% in 24 uur, met een marktkapitalisatie van $576 miljoen;</p>
<p>-ARC steeg met 29,1% in 24 uur, met een marktkapitalisatie van $340 miljoen;</p>
<p>-GRIFFAIN steeg in 24 uur tijd met 31,6%, met een marktkapitalisatie van $270 miljoen.</p>
<h2 id="h2-Markttrends20ELIZA20steeg20binnen20de20dag20met206020HYPE20lanceerde20de20stakingfunctie993446"><a name="Markttrends: ELIZA steeg binnen de dag met 60%, HYPE lanceerde de staking-functie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: ELIZA steeg binnen de dag met 60%, HYPE lanceerde de staking-functie</h2><h3 id="h3-Markt20Hotspots569050"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De meme sector ELIZA, GOAT, PNUT, etc. is gestegen, waarbij ELIZA de sector leidt met een stijging van 60%. ELIZA is een door ai16z gerelateerd project en de updatevolume op github stond in december op de eerste plaats; de huidige marktkapitalisatie van ELIZA bedraagt ​​$130 miljoen, wat 474e is op de hele markt. In vergelijking met andere AI-conceptprojecten heeft ELIZA mogelijk nog wat groeiruimte.</p>
<p>Het hot project van deze maand, Hyperliquid, heeft de HYPE-stakingfunctie gelanceerd en de marktkapitalisatie van HYPE is al een week lang rond de $9 miljard gebleven; de huidige omloop van HYPE is slechts ongeveer 33%, en de totale omloopmarktwaarde is maar liefst $27 miljard.</p>
<h3 id="h3-Mainstream20Munten563580"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC is de afgelopen drie opeenvolgende weken gedaald, maar de algehele correctie is niet significant. BTC ETF-uitstroom is de afgelopen twee weken toegenomen en naar schatting kan januari nog steeds een volatiele markt zijn;</p>
<p>ETH presteerde relatief goed en blijft in de buurt van $3.350. Het Altcoin-seizoen moet wachten tot de ETH/BTC-wisselkoers omkeert;</p>
<p>Altcoins vielen over het algemeen en er zijn weinig markthete plekken. De AI-sector verdient op lange termijn aandacht.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20sloten20lager20Goldman20Sachs20voorspelt20dat20de20Fed20in20maart20opnieuw20de20rente20zal20verlagen22237"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten lager, Goldman Sachs voorspelt dat de Fed in maart opnieuw de rente zal verlagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten lager, Goldman Sachs voorspelt dat de Fed in maart opnieuw de rente zal verlagen</h2><p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, waarbij de S&amp;P 500 met 1,07% daalde tot 5.906,94 punten; de Dow Jones-index met 0,97% daalde tot 42.573,73 punten; en de Nasdaq daalde met 1,19% tot 19.486,79 punten. Het referentiepunt van de 10-jarige Amerikaanse staatsobligatierente bedraagt 4,55%, en de 2-jarige Amerikaanse staatsobligatierente, die het meest gevoelig is voor het rentebeleid van de Fed, bedraagt 4,24%.</p>
<p>Goldman Sachs heeft een rapport uitgegeven waarin voorspeld wordt dat de Federal Reserve de rente in maart volgend jaar met nog eens 25 basispunten zal verlagen en vervolgens de rente in juni en september volgend jaar nog eens met 25 basispunten zal verlagen, waarbij de eindpuntrente 3,5 tot 3,75% zal zijn. De bank verwacht ook dat de Fed haar balansverkorting volgende maand zal vertragen en haar balans in het tweede kwartaal zal stoppen met krimpen.</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 standpunten van de onderzoeker en vormt geen beleggingsaanbevelingen. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat 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>