RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYncyBoYWRkZW4gZWVuIGdyb3RlIHVpdHN0cm9vbSwgbWFhciBCVEMgc3RlZWcgaW4gcGxhYXRzIHZhbiB0ZSBkYWxlbiwgR1QgYnJhayBkb29yICQxNy43IGVuIHZlc3RpZ2RlIGVlbiBuaWV1dyByZWNvcmRob29ndGU=

2025-01-03, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/173587613512.06.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20enkele20dagelijkse20uitstroom20van20BlackRock20IBIT20bereikte20een20nieuw20hoogtepunt20sinds20de20lancering20Xterio20kondigde20zijn20token20economie20aan349778"><a name="Crypto Dagelijks Overzicht: De enkele dagelijkse uitstroom van BlackRock IBIT bereikte een nieuw hoogtepunt sinds de lancering, Xterio kondigde zijn token economie aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De enkele dagelijkse uitstroom van BlackRock IBIT bereikte een nieuw hoogtepunt sinds de lancering, Xterio kondigde zijn token economie aan</h2><p>Volgens de gegevens van Farside Investors was gisteren de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had een grote nettostroom van $240 miljoen, waarvan BlackRock IBIT een uitstroom had van $330 miljoen, wat de grootste enkelvoudige dagelijkse uitstroom was sinds BlackRock IBIT online ging; Fidelity FBTC had een nettostroom van $36,2 miljoen, en Bitwise BITB had een instroom van $48,3 miljoen.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had een nettostroom van $77,5 miljoen, waarvan Bitwise ETHW een uitstroom had van $56,1 miljoen en Grayscale ETHE een uitstroom had van $21,4 miljoen. BlackRock IBIT-gegevens zijn nog niet bijgewerkt.</p>
<p><strong>Xterio heeft de XTER-tokeneconomie aangekondigd, waarbij 28% is toegewezen aan de gemeenschap</strong></p>
<p><a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Het gamingplatform Xterio heeft een bericht gepubliceerd op het X-platform waarin staat dat de token-economie is aangekondigd en de totale voorraad van XTER 1 miljard is. De initiële omloop van XTER is 112,5 miljoen en de TGE zal plaatsvinden op 8 januari. Daarvan:</p>
<p>-28% voor de gemeenschap, en 20 miljoen tokens zullen volledig worden vrijgegeven bij TGE;</p>
<p>-26% voor het ecosysteem, en 20 miljoen tokens zullen volledig worden ontgrendeld bij TGE;</p>
<p>-15% voor de investeerders;</p>
<p>-12% voor het team;</p>
<p>-9% voor marketing, en 15 miljoen tokens zullen volledig ontgrendeld zijn bij TGE;</p>
<p>-4,25% voor de kluis en 5,75% van de tokens worden gebruikt om liquiditeit te verschaffen en te staken wanneer TEG.</p>
<p><strong>VanEck onderzoeksdirecteur: De waarschijnlijkheid dat de VS in 2025 SOL ETF’s goedkeurt, is “zeer hoog”</strong></p>
<p><a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Cryptovoorspelling</a> Het platform Polymarket heeft eerder verklaard dat de waarschijnlijkheid van een <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het percentage van ETF’s dat in 2025 in de Verenigde Staten wordt genoteerd, bedraagt ongeveer 77%.</p>
<p>Matthew Sigel, hoofd onderzoek bij VanEck, zei dat de voorspelling was “onderschat.” In juni 2024 vroegen VanEck en concurrent asset management bedrijf 21Shares toestemming aan Amerikaanse toezichthouders om de spot <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ETF te noteren. In november vorig jaar, kort nadat Trump de Amerikaanse presidentsverkiezingen had gewonnen, zei Matthew Sigel dat de waarschijnlijkheid dat de VS de SOL ETF in 2025 goedkeurde “zeer hoog” was.</p>
<p><strong>Sommige AI-concepttokens vielen terug, en ELIZA viel 31,3% in 24 uur</strong></p>
<p>Volgens Gate.io marktinformatie zijn vandaag enkele AI-concepttokens gedaald op de markt, waaronder:</p>
<p>-ELIZA daalde met 31,3% in 24 uur en de marktkapitalisatie is nu $112 miljoen;</p>
<p>-SPORE daalde met 25,1% in 24 uur, en de marktkapitalisatie bedraagt nu $52,85 miljoen;</p>
<p>-GAME (GAME door Virtuals) daalde met 21,8% in 24 uur, met een marktkapitalisatie van $299 miljoen;</p>
<p>-LUNA (Luna by Virtuals) is in 24 uur met 21% gedaald en heeft nu een marktkapitalisatie van $138 miljoen.</p>
<h2 id="h2-Markttrends20GT20bereikte20een20nieuw20recordhoogte20trendende20AI20Agent20concept20tokens20trokken20zich20terug84538"><a name="Markttrends: GT bereikte een nieuw recordhoogte, trendende AI Agent concept tokens trokken zich terug" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: GT bereikte een nieuw recordhoogte, trendende AI Agent concept tokens trokken zich terug</h2><h3 id="h3-Markt20Hotspots3724"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>GT brak door de $17,7, waarmee een nieuw recordhoogte werd bereikt; volgens Doctor.Han is 2024 het snelst groeiende jaar voor Gate.io in 11 jaar. Het aantal Gate.io-gebruikers overschreed de 20 miljoen, wat neerkomt op een groei van 50% van het aantal gebruikers, een groei van 100% van het handelsvolume (verdubbeling), een groei van 200% van de reserves (verdrievoudiging) en een groei van 300% van de marktkapitalisatie van GT (verviervoudiging). Daarnaast overschreden de reserves van het Gate.io-platform $10 miljard en bereikte GT ook een recordhoogte in het vierde kwartaal met de groei van het gehele platform. Gedurende het hele jaar werden in totaal $33,49 miljoen aan airdrop-beloningen uitgestuurd door Startup, en Yubibao bracht $100 miljoen aan rente voor gebruikers van financieel beheer.</p>
<p>GameFi-token MAGIC steeg met 20% op de dag. MAGIC’s prestaties in deze ronde van marktprestaties waren aanzienlijk lager dan die van populaire tracktokens, en ook lager dan die van BTC. MAGIC steeg omdat Shaw, de oprichter van ai16z, eerder een belangrijk lid was van het Magic-project, en de oververhitte fondsen van AI Agent hun aandacht richtten op andere gerelateerde doelen op de baan.</p>
<p>Trending AI Agent tokens zoals VIRTUAL en AIXBT zijn terugglen, en VIRTUAL heeft zijn marktkapitalisatie van $5 miljard nog niet gestabiliseerd. De AI Agent track is oververhit en de marktsentiment is extreem fomo, wat aangeeft dat de markt tijdelijk een fase van aanpassing kan ingaan;</p>
<h3 id="h3-Mainstream20Munten443321"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC staat weer boven $97.000. BTC ETF’s hadden gisteren een kleine instroom. BTC is nog steeds bullish op middellange en lange termijn.</p>
<p>ETH nadert weer de $3.500 grens en laat een relatief sterke prestatie zien.</p>
<p>Gemengde prestaties van altcoins, met duidelijke rotatie van de marktkapitalisatie. Grote altcoins hebben weinig ruimte voor groei, terwijl kleine tokens op de keten meer kansen hebben.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20daalden20over20het20algemeen20Amerikaanse20obligaties20stegen20en20de20Amerikaanse20dollar20waardeerde20aanzienlijk723996"><a name="Macro nieuws: Amerikaanse aandelen daalden over het algemeen, Amerikaanse obligaties stegen en de Amerikaanse dollar waardeerde aanzienlijk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen daalden over het algemeen, Amerikaanse obligaties stegen en de Amerikaanse dollar waardeerde aanzienlijk</h2><p>De drie belangrijkste Amerikaanse aandelenindexen sloten gezamenlijk lager, waarbij de S&amp;P 500 met 0,22% daalde tot 5.868,55 punten, de Dow Jones met 0,36% daalde tot 42.392,27 punten en de Nasdaq met 0,16% daalde tot 19.280,79 punten. Het referentiepunt van de 10-jarige Amerikaanse schatkistrendement bedroeg 4,57% en het rendement op de 2-jarige schatkist, dat het meest gevoelig is voor het rentetarief van de Fed, bedroeg 4,25%.</p>
<p>Analisten van HSBC Global Research zeiden dat de sterke stijging van de Amerikaanse schatkistrendementen en de daaropvolgende waardering van de Amerikaanse dollar de belangrijkste marktontwikkelingen van de afgelopen weken waren. Deze winsten werden gedreven door ‘een nieuwe ronde van onverwacht positieve tekenen van Amerikaanse economische activiteit en tekenen van een hernieuwde stijging van de Amerikaanse inflatie’, die samen met de renteverlaging van de Federal Reserve in december hebben geleid tot een scherpe aanpassing van de Amerikaanse renteverwachtingen.</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 mening van de onderzoeker en vormt geen beleggingsadvies. Alle beleggingen 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 er verwezen wordt naar Gate.io. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>