RGFnZWxpamtzIG5pZXV3cyB8IFZJUlRVQUwgbGVpZGRlIGhldCBjb25jZXB0IHZhbiBkZSBBSS1hZ2VudCB0b3QgZWVuIHN0aWpnaW5nLCBBSTE2WiBiZXJlaWt0ZSBlZW4gbmlldXcgcmVjb3JkaG9vZ3Rl

2025-01-02, 03:49

<p><img src="https://gimg2.gateimg.com/image/article/173578952212.05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20AI16Z20bereikt20nieuwe20hoogtepunten20Goldman20Sachs20verlaagt20voorspelling20voor20Fedrente20verlaging20dit20jaar20naar207520basispunten757885"><a name="Crypto Dagelijks Overzicht: AI16Z bereikt nieuwe hoogtepunten, Goldman Sachs verlaagt voorspelling voor Fed-rente verlaging dit jaar naar 75 basispunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: AI16Z bereikt nieuwe hoogtepunten, Goldman Sachs verlaagt voorspelling voor Fed-rente verlaging dit jaar naar 75 basispunten</h2><p>Volgens gegevens van Farside Investors, op dinsdag, de Verenigde Staten. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF zag een kleine nettostroom van $5,3 miljoen, waarvan BlackRock IBIT een nettostroom van $23,5 miljoen had, Fidelity FBTC een nettostroom van $36,8 miljoen had, en Grayscale GBTC een uitstroom van $9,6 miljoen had; Het nettobedrag van Ether in spot ETF’s was $36 miljoen, waarvan Fidelity FETH een instroom van $31,8 miljoen had en Grayscale ETH een instroom van $9,8 miljoen had.</p>
<p>De Amerikaanse aandelenmarkt was gesloten op woensdag, dus de instroom en uitstroom van ETF-gegevens voor woensdag zijn niet bijgewerkt.</p>
<p><strong>De stijging van tokens in de AI-sector gaat door, met GRIFFAIN, FAI, enz. die recordhoogtes blijven bereiken</strong></p>
<p>Volgens de marktinformatie van Gate.io gaat de rally van tokens in de AI-sector vandaag door, waarbij ai16z, GRIFFAIN en anderen blijven stijgen naar recordhoogtes:</p>
<p>De marktkapitalisatie van ai16z overtrof kortstondig $2,5 miljard en wordt nu verhandeld op $2,45 miljard, met een stijging van 35,98% in de afgelopen 24 uur;</p>
<p>De marktkapitalisatie van GRIFFAIN overtrof kortstondig $470 miljoen en wordt nu verhandeld op $446 miljoen, een stijging van 17,05% in 24 uur;</p>
<p>-De marktkapitalisatie van FAI overschreed kortstondig $398 miljoen en staat nu op $375 miljoen, een stijging van 31,92% in 24 uur;</p>
<ul>
<li>De marktkapitalisatie van  overtrof kortstondig 83 miljoen dollar en wordt nu verhandeld op 78 miljoen dollar, een stijging van 87,58% in 24 uur.</li></ul>
<p><strong>Bitcoin “verkoopdruk” duwt Coinbase-premie-index naar laagste niveau van 12 maanden</strong></p>
<p>CryptoQuant-analist Burakkesmeci zei in een rapport: ‘Groeiende verkopersdruk op de Amerikaanse markt heeft aanzienlijke invloed gehad op de Coinbase Premium Index, waardoor deze naar een nieuw dieptepunt van 12 maanden is gezakt.’</p>
<p>De Coinbase Premium Index - een maatstaf voor de Amerikaanse retailvraag naar <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> - daalde tot een 12-maands dieptepunt eind 2024, waarbij analisten waarschuwden dat dit een uitdaging zou kunnen vormen voor het herstel van de Bitcoin-prijs op korte termijn.</p>
<p>Op 31 december 2024 bereikte de index een dieptepunt van -0,23. Burakkesmeci schreef dit toe aan ‘lage liquiditeit op de markt aan het einde van het jaar’. De laatste keer dat de index dit niveau bereikte was in januari 2024, toen er in de Verenigde Staten een spot Bitcoin exchange-traded fund (ETF) werd gelanceerd.</p>
<p><strong>Goldman Sachs verlaagt voorspelling voor Fed-rente verlaging dit jaar naar 75 basispunten</strong></p>
<p>Goldman Sachs heeft een rapport uitgegeven waarin staat dat de voorspelling van de Federal Reserve om dit jaar de rentetarieven te verlagen, is verlaagd van 100 basispunten naar 75 basispunten, en dat de rapporten van een herstel van de onderliggende inflatie sterk overdreven zijn. De kern-PCE-inflatie steeg met een geannualiseerd percentage van 2,5% van september tot november vorig jaar, iets hoger dan de 2,3% stijging in de voorgaande drie maanden, maar lager dan de 2,8% jaar-op-jaar stijging en nog steeds in overeenstemming met een voortdurende daling.</p>
<p>Het rapport wees er ook op dat de geannualiseerde PCE-inflatie, gecorrigeerd voor gemiddelde PCE-inflatie door de Dallas Fed, 2,4% bedroeg van september tot november vorig jaar en 1,8% in november vorig jaar. Naarmate de arbeidsmarkt weer strakker wordt op het niveau van 2017, is de loongroei vertraagd tot een jaarlijks niveau van 3,9%, in het bereik van 3,5 tot 4%, wat in lijn zou zijn met een inflatie van 2% als de productiviteit met 1,5 tot 2% groeit in de komende jaren.</p>
<h2 id="h2-Markttrends20VIRTUAL20leidde20het20concept20van20de20AIagent20naar20boven20en20de20FTMmuntwisseling20steeg20met2020949053"><a name="Markttrends: VIRTUAL leidde het concept van de AI-agent naar boven, en de FTM-muntwisseling steeg met 20%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: VIRTUAL leidde het concept van de AI-agent naar boven, en de FTM-muntwisseling steeg met 20%.</h2><h3 id="h3-Markt20Hotspots381951"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>-AI Agent sector tokens zoals VIRTUAL, AI16Z, SWARMS, ELIZA, GOAT, enz. zijn over het algemeen gestegen. AI Agent concept tokens zullen de markt leiden in december 2024. Dit concept wordt verwacht door te gaan in deze stierenmarkt en kan leiden tot nieuwe A-ronde van markttrends; VIRTUAL heeft op dit moment een marktkapitalisatie van $4,8 miljard en is de welverdiende leidende token in het AI Agent concept geworden;</p>
<p>-De openbare ketentoken FTM is bijna 20% gestegen. FTM staat op het punt om zijn merk te upgraden naar Sonic. De FTM-token zal ook worden omgeruild voor Sonic’s token S in een verhouding van 1:1. Gate.io heeft aangekondigd dat het muntswap ondersteunt en dat gebruikers op het platform niets hoeven te doen. Migratie kan worden voltooid;</p>
<p>De populaire mememunt KEKIUS op de keten is gedaald, mogelijk als gevolg van Musk die zijn Twitter-avatar weer heeft veranderd in zijn originele naam. De KEKIUS-token op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Chain viel binnen een dag van een maximale marktkapitalisatie van 400 miljoen dollar terug naar een huidige marktkapitalisatie van 85 miljoen dollar.</p>
<h3 id="h3-Mainstream20Munten605133"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC steeg lichtjes en consolideerde nog steeds rond de $95.000. BTCD daalde lichtjes en geld stroomde naar Altcoins;</p>
<p>ETH consolideert rond $3.400 en het zal nodig zijn dat BTC scherp stijgt voordat fondsen weer voor ETH kiezen;</p>
<p>Altcoins stegen over het algemeen, het concept van de AI Agent steeg en de Desci sector presteerde ook goed.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20sloten20dinsdag20collectief20lager20en20de20drie20belangrijkste20Amerikaanse20aandelenindexen20bereikten20herhaaldelijk20nieuwe20hoogtepunten20in202024359828"><a name="Macro Nieuws: Amerikaanse aandelen sloten dinsdag collectief lager en de drie belangrijkste Amerikaanse aandelenindexen bereikten herhaaldelijk nieuwe hoogtepunten in 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen sloten dinsdag collectief lager en de drie belangrijkste Amerikaanse aandelenindexen bereikten herhaaldelijk nieuwe hoogtepunten in 2024</h2><p>Op dinsdag sloten de drie belangrijkste Amerikaanse aandelenindexen gezamenlijk lager, waarbij de S&amp;P 500 met 0,43% daalde tot 5.881,63 punten; de Dow Jones-index met 0,07% daalde tot 42.544,22 punten; en de Nasdaq met 0,90% daalde tot 19.310,79 punten. Het referentiepunt voor de 10-jarige Amerikaanse staatsobligatierente is 4,58% en de 2-jarige Amerikaanse staatsobligatierente, die het meest gevoelig is voor het rentebeleid van de Fed, is 4,25%.</p>
<p>Volgens China Business News zullen de drie belangrijkste Amerikaanse aandelenindices de test in 2024 doorstaan en herhaaldelijk nieuwe hoogtepunten bereiken. Onder hen steeg de Nasdaq 100 Index het hele jaar door met 27%, de S&amp;P 500 Index steeg met 24% en de Dow Jones Industrial Index steeg met 13%. Investeringsbanken van Wall Street voorspellen dat de rally zich dit jaar naar verwachting zal voortzetten. Sommige commentatoren zeiden dat Wall Street, ondanks de sterke stijging van Amerikaanse aandelen vorig jaar, nog steeds unaniem optimistisch is over de trend van Amerikaanse aandelen dit jaar. De belangrijkste redenen zijn: (1) Fundamenteel bevindt de Amerikaanse economie zich nog steeds in een staat van hoge groei en lage inflatie; (2) Een renteverlaging is een zeer waarschijnlijke gebeurtenis; (3) Er is misschien geen betere keuze op de beleggingsmarkt, en de Europese economie loopt nog steeds risico, en Japan loopt nog steeds risico als gevolg van de appreciatie van de yen. Er is enige onzekerheid. Daarom, zelfs als de Amerikaanse aandelenmarkt het risico loopt van een te hoge waardering, kan dit worden opgelost door de snelle stijging van de bedrijfswinsten. Met name de belastingverlagingen en versoepelde regelgeving van het Trump 2.0-beleid kunnen gunstig zijn voor de verbetering van de bedrijfswinsten. Het risico van een hoge waardering van Amerikaanse aandelen kan beheersbaar zijn.</p>
<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 opvattingen 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 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>