V2VrZWxpamtzIFdlYjMtb25kZXJ6b2Vr772cTWFya3QgYmxlZWYgZGUgaHVpZGlnZSBvc2NpbGxhdGllY3ljbHVzIHZvb3J0emV0dGVu

<p><img src="https://gimg2.gateimg.com/image/article/1740119412weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht442004"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>Deze week, het algemene <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> bleef zijn recente oscillatiecyclus voortzetten. Net als de marktveranderingen van vorige week, is er nog steeds geen duidelijk opwaarts signaal in de markt, en wordt het grootste deel van de week gedomineerd door kleine schommelingen. Deze week wordt de markt voornamelijk gedomineerd door kleine ups en downs binnen de dag, en de trend van mainstream munten mist in principe grote schommelingen. Naarmate het einde van de week nadert, liggen de prijzen van de meeste mainstream munten in principe in hetzelfde bereik als de openingsprijs, en is er op korte termijn geen mogelijkheid tot grootschalige veranderingen in de trend.</p>
<p>De meeste belangrijke cryptocurrencies vertoonden deze week geen duidelijke ups en downs, en er was een lichte daling na de opening van deze week. De markttrend op korte termijn is echter nog steeds zeer onduidelijk, en er wordt verwacht dat er op korte termijn ups en downs zullen zijn gedurende de dag.</p>
<p>Deze week bleef de prijs van BTC voor het grootste deel van de tijd in het bereik van $94.000-$99.000, maar er was een aanzienlijke daling in de midden van de week en de prijs daalde in korte tijd onder de $94.000. Het dieptepunt van BTC lag rond $93.487, maar het bleef voor het grootste deel van de week boven de $95.000 en bleef fluctueren, waarbij het hoogtepunt doorbrak naar $98.000.</p>
<p>Vergeleken met BTC, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> Schommelingen zijn groter, met een wekelijkse hoogtepunt van ongeveer $2,819 en een dieptepunt van ongeveer $2,617. Deze week bleven de prijstrends van de meeste belangrijke mainstream munten stijgen en dalen binnen een kleine marge. De marktsentiment is niet significant veranderd en blijft rond 40. De totale marktwaarde van de cryptomarkt is licht gestegen, met ongeveer $3,21 biljoen, een stijging van 1,11% in 24 uur.</p>
<p>De algehele cryptomarkt handhaafde deze week zijn recente cyclische trend, met een relatief duidelijke stijging en daling. De huidige prijs van BTC ligt rond de $98,300. De huidige prijs van ETH ligt rond de $2,740.</p>
<p>De algehele cryptomarkt kent deze week geen duidelijke ups en downs en er is geen trend van verdere grootschalige veranderingen. De huidige prijzen van een aanzienlijk aantal mainstream munten liggen in hetzelfde bereik als de openingsprijzen. De topmunt met de grootste stijging deze week is IP, die in een week met ongeveer 110% is gestegen.</p>
<p>De cryptomarkt wordt verwacht dit weekend binnen het huidige bereik te blijven, waarbij korte termijn schommelingen de belangrijkste trend blijven.</p>
<h2 id="h2-Crypto20Markt836817"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>Volgens Cointelegraph toonden de gegevens van CoinGlass aan dat vanaf 10:35 uur UTC op 16 februari meer dan 70% van de openstaande contracten voor ETH-opties koopcontracten waren. Onderzoeksanalist Nicolai Sondergaard van Nansen zei dat bullish-posities aangeven dat investeerders voorzichtig optimistisch zijn over de middellange termijnwaardering van ETH.</p>
<p>🔥Crypto-analist Immortal tweette: “BTC on-chain transactievolume is verre van 2021-niveaus… maar verwachten we een grote bull run? Zelfs transactiekosten geven niet per se een bull run aan - kijk gewoon naar eerdere cycli.”</p>
<p>🔥Volgens Cointelegraph, volgens een studie uitgevoerd door Perryman Group en vrijgegeven door blockchain-belangenbehartigingsorganisaties Texas Blockchain Council en Digital Chamber of Commerce, ondanks dat het een opkomend veld is, is de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Beurs</a> De mijnbouwindustrie heeft rechtstreeks via mijnbouwactiviteiten en onrechtstreeks via ondersteunende industrieën meer dan 31.000 banen gecreëerd in de Verenigde Staten.</p>
<p>Volgens Crypto.news zei medeoprichter van Coingecko, Bobby Ong, dat de cryptomarkt in januari een toename zag in de creatie van nieuwe tokens, met 600.000 nieuwe tokens gemunt, een toename van 12 keer van de 50.000 tokens per maand van 2022 tot 2023.</p>
<p>🔥Adam, een macro-onderzoeker bij Greeks.live, heeft een Engelse gemeenschapsbriefing vrijgegeven waarin staat dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>-handelaren het bereik van $ 94.000-98.000 nauwlettend in de gaten houden, met het belangrijkste weerstandsniveau op $ 98.000. Tegelijkertijd hebben veel mensen gemerkt dat de volatiliteit de laatste tijd ongewoon laag is en dat er een gebrek aan zekerheid is in de prijsontwikkelingen.</p>
<p>🔥Ray Dalio, oprichter van Bridgewater Funds, sprak opnieuw over <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in het laatste ‘All-In’ podcastinterview en noemde de DeepSeek-rage. Hij zei dat hij valutaduatie zag door marktontwikkelingen, vooral ten opzichte van goud, Bitcoin of andere fysieke activa.</p>
<p>🔥Adam, een macro-onderzoeker bij Greeks.live, schreef op het X-platform dat het meest opmerkelijke macro-nieuws van deze week afkomstig is uit de Verenigde Staten en Europa over de oorlog tussen Rusland en Oekraïne. De oorlog tussen Rusland en Oekraïne is altijd een belangrijke reden geweest voor de stijging van de grondstofprijzen. Als de relevante situatie verandert, kan dit een verandering veroorzaken in de huidige algehele inflatielogica.</p>
<p>🔥Volgens monitoring door crypto-analist Ali, stroomt het kapitaal naar Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zijn in de afgelopen maand aanzienlijk gedaald, van $45 miljard naar $30 miljard, een daling van meer dan 30%.</p>
<p>🔥Volgens Cryptoslate hielden institutionele beleggers op 31 december 2024 25,4% van de activa onder beheer (AUM) van spot Bitcoin ETF’s, met een totaal van $26,8 miljard.</p>
<p>Volgens Cryptoslate is versie 1.15.2 van Geth, een belangrijke client van het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>-protocol, uitgebracht om een bug in de vorige versie op te lossen die van invloed was op de creatie van mainnet-blokken. Volgens Go <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> lost deze noodupdate een regressieprobleem op in de beacon consensus engine dat validators deed missen op blokmogelijkheden en mogelijk economische verliezen veroorzaakte.</p>
<p>🔥Volgens Cointelegraph, met de opkomst van de Amerikaanse president Donald Trump, zijn steeds meer witteboordencriminelen, waaronder voormalig FTX-CEO SBF, op zoek naar manieren om vergeving te verkrijgen.</p>
<p>🔥Michael Saylor, oprichter van Strategy (voorheen MicroStrategy), tweette een samenvatting van de ‘21 regels van Bitcoin’.</p>
<p>Volgens Cryptoslate heeft de European Securities and Markets Authority (ESMA) een openbare raadpleging gelanceerd over richtsnoeren voor het beoordelen van de kennis en competentie van professionals die cryptovermogensdiensten verlenen onder de Crypto Asset Market Regulation (MiCA).</p>
<p>🔥Volgens Cointelegraph onthulde het investeringsinstituut van miljardair Paul Tudor Jones dat het BlackRock IBIT ter waarde van $426,9 miljoen aanhoudt, wat twee keer zoveel is als de laatste keer dat het zijn bezittingen rapporteerde in SEC-documenten.</p>
<p>🔥Volgens Crypto Briefing, Kyle Song, <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Een expert bij Google Cloud Asia Pacific onthulde tijdens zijn toespraak op het Hong Kong Bitcoin Technology Carnival dat Google zich inzet om Bitcoin wallets zo gebruiksvriendelijk te maken als Web2-toepassingen. Google’s visie is om gebruikers in staat te stellen in te loggen op Bitcoin wallets met hun bestaande Google-accounts. Het doel van deze inspanning is om Bitcoin dichter bij de mainstream gebruikers te brengen.</p>
<p>Volgens CoinDesk toonde een rapport van JPMorgan Chase aan dat in februari 2025 de in de VS genoteerde Bitcoin miners goed waren voor 29% van de wereldwijde rekenkracht van het Bitcoin-netwerk, bijna het dubbele van dezelfde periode vorig jaar.</p>
<p>🔥Volgens de on-chain analist Ember, hoewel de ETH/BTC wisselkoers is gedaald tot 0,028, zijn er nog steeds walvissen die neerkijken op de ETH/BTC wisselkoers: een walvis heeft in de afgelopen twee weken in totaal 1.444 cbBTC (ongeveer $138 miljoen) van Coinbase opgenomen en vervolgens gestort in <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> als onderpand om 29.025 ETH (ongeveer $77,6 miljoen) te lenen en vervolgens over te maken naar Coinbase.</p>
<p>🔥Volgens The Daily Hodl, waarbij Barron’s wordt aangehaald, terwijl de financiële dienstengigant Charles Schwab zijn zakelijke tentakels uitbreidt naar cryptobeleggingen, richt het bedrijf een nieuwe leidinggevende positie op. Deze nieuwe positie is het hoofd van digitale activa, die verantwoordelijk zal zijn voor de algehele crypto-activastrategie van Schwab.</p>
<p>Volgens TheBlock heeft Vetle Lunde, hoofd onderzoek bij K33 Research, in een rapport geanalyseerd dat Bitcoin nog steeds in een lage volatiliteitsbereik zit. Deze week daalde Bitcoin lichtjes met 2% omdat risicomijdende handelaren de opbrengsten, volatiliteit en handelsvolumes naar meermaandelijkse dieptepunten duwden.</p>
<p>🔥Volgens Bloomberg, Reeve Collins, een van de oorspronkelijke oprichters van <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>, lanceert zijn eigen stablecoin.</p>
<p>🔥 Volgens The Block zei Strategy (voormalig MicroStrategy) dinsdag dat het van plan is om $2 miljard aan renteloze converteerbare senior obligaties uit te geven, enkele uren nadat het een winstwaarschuwing had afgegeven.</p>
<p>Volgens Bloomberg heeft het crypto-beveiligingsplatform Blockaid onlangs een Series B-financieringsronde van $50 miljoen afgerond, geleid door Ribbit Capital, met deelname van GV (voorheen Google Ventures) en bestaande investeerders Variant en Cyberstarts.</p>
<p>🔥Trump zei op de conferentie van het Institute for Future Investment Initiative in Miami op woensdag: ‘Bitcoin heeft meerdere all-time highs bereikt omdat iedereen weet dat ik me ervoor inzet om de Verenigde Staten de hoofdstad van cryptocurrency te maken.’</p>
<p>🔥Ki Young Ju, CEO van CryptoQuant, zei dat hij gelooft dat Bitcoin dit jaar niet in een bearmarkt zal komen en nog steeds in een bullmarkt zit.</p>
<h2 id="h2-Regelgeving20en20macrobeleid528923"><a name="Regelgeving en macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgeving en macrobeleid</h2><p>Volgens The Block hebben Argentijnse advocaten een rechtszaak aangespannen tegen de president van het land, Javier Milei, waarin hij wordt beschuldigd van fraude vanwege zijn betrokkenheid bij het LIBRA-tokenproject, een schandaal dat escaleerde nadat het uitbrak in het weekend toen de waarde van het token met 95% daalde na de eerste promotie van Milei.</p>
<p>Ondertussen zou Javier Milei geconfronteerd kunnen worden met afzetting in het Congres vanwege beschuldigingen dat hij een crypto rug pull vergemakkelijkte die ervoor zorgde dat de marktwaarde van de token in een paar uur tijd daalde van $4 miljard naar $418 miljoen.</p>
<p>🔥Volgens de Hong Kong Wen Wei Po verwachtte een fondsbeheerder eerder de lancering van het eerste getokeniseerde retail-geldmarktfonds in de regio Azië-Pacific in Hong Kong tegen het einde van deze maand. De Chief utive Officer van de Hong Kong Securities and Futures Commission, Leung Fung-yee, zei dat ze het Ensemble-project met de HKMA had besproken en geloofde dat geldmarktfondsen het grootste potentieel hebben voor tokenisatie onder real-world assets omdat ze inschrijving en terugbetaling efficiënt kunnen maken. Momenteel worden veel andere tokenisatietoepassingen beoordeeld, waaronder retailproducten en geldmarktfondsen.</p>
<p>Volgens Cointelegraph heeft de Texaanse overheidswebsite aangekondigd dat de eerste openbare hoorzitting over de oprichting van een mogelijke strategische Bitcoin-reserve in Texas gepland staat voor 18 februari, minder dan een week nadat de Senaatssecretaris het wetsvoorstel heeft ontvangen.</p>
<p>🔥Volgens de website van de Hong Kong Radio wordt verwacht dat Ye Zhiheng, uitvoerend directeur van de Intermediairsafdeling van de Hong Kong Securities and Futures Commission, deze maand een roadmap voor de ontwikkeling van virtuele activa zal aankondigen. Naast het uitleggen van de ontwikkelingsprincipes, zal de roadmap ook de verwachtingen van de SFC en het bereik van marktonderzoek op korte termijn vermelden, evenals de gebieden waar platformdeelnemers hopen te optimaliseren.</p>
<p>🔥Volgens Cointelegraph heeft de Amerikaanse effectenbeurs MEMX een aanvraag ingediend bij de Securities and Exchange Commission (SEC) om de 21Shares te laten noteren. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF als een “commodity trust,” en de relevante documenten zijn ingediend bij de toezichthouder. Deze stap markeert een nieuwe inspanning van Amerikaanse beurzen om ETF’s op te nemen die spot <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> bevatten. Deze aanvraag benadrukt ook de verschuiving in de houding van de SEC ten opzichte van cryptocurrencies.</p>
<p>🔥Volgens The Block zoekt de U.S. Securities and Exchange Commission (SEC) publieke reacties om te beslissen of de handel in opties moet worden goedgekeurd voor drie spot Ethereum ETF’s. Volgens een regelgevend document dat op dinsdag is vrijgegeven, heeft de SEC meningen gezocht over het al dan niet toestaan van de Chicago Board Options Exchange (Cboe Exchange, Inc.) om opties te noteren en verhandelen op de Grayscale Ethereum Trust ETF, Grayscale Ethereum Mini Trust ETF en Bitwise Ethereum ETF.</p>
<p>🔥Volgens de officiële website van het Amerikaanse ministerie van Justitie hebben Amerikaanse aanklagers een civiele verbeurdverklaring aangespannen in een zaak van crypto-investeringsfraude en 7,24 BTC, 14.120 USDT, 105,75 ETH en andere crypto-activa teruggevorderd.</p>
<p>🔥De lijst van stablecoin-uitgevers die voldoen aan de ‘Markets in Crypto-Assets Act’ (MiCA) van de EU is aangekondigd. Tien instellingen, waaronder Circle, Crypto.com en Societe Generale, zijn goedgekeurd om euro- en Amerikaanse dollar-stablecoins uit te geven, wat in totaal 10 euro-stablecoins en 5 Amerikaanse dollar-stablecoins omvat.</p>
<p>Volgens Decrypt heeft de U.S. Securities and Exchange Commission (SEC) vrijwillig zijn beroep ingetrokken tegen een uitspraak die de instantie ervan weerhield bestaande effectenwetten uit te breiden om DeFi-gebruikers en -projecten te bestrijken.</p>
<p>🔥Volgens Satoshi Action Fund werd Montana’s “Strategic Bitcoin Reserve”-wet in de commissie aangenomen en ging het de stemfase van het Huis van Afgevaardigden in.</p>
<p>🔥De U.S. Securities and Exchange Commission (SEC) heeft officieel bevestigd dat het de spot heeft geaccepteerd <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ETF (LITE) aanvraag ingediend door CoinShares.</p>
<p>🔥Volgens CoinDesk zei Ales Michl, gouverneur van de Tsjechische centrale bank, dat Bitcoin aanzienlijk verschilt van andere crypto-activa en niet verward moet worden met cryptocurrencies.</p>
<p>🔥Volgens Edaily heeft de Financial Supervisory Service (FSS) van Zuid-Korea haar inspectieplan voor dit jaar bekendgemaakt, waarin zij de toezicht op aanbieders van virtuele activa (VASP’s) wil versterken. FSS is van plan streng te controleren of deze platforms voldoen aan wetten en voorschriften, evenals vrijwillige nalevingsregels.</p>
<p>Volgens CoinDesk kondigde Franklin Templeton de lancering aan van het eerste volledig getokeniseerde Amerikaanse schatkistbondefonds in Luxemburg, waardoor Europese institutionele beleggers de mogelijkheid krijgen om deel te nemen.</p>
<p>Volgens de laatste regelgevingsroadmap ‘A-S-P-I-Re’ die is uitgebracht door de Securities and Futures Commission (SFC) van Hong Kong, zal Hong Kong het toezicht op de virtuele activamarkt verder verbeteren om innovatie en risicobeheer in evenwicht te brengen.</p>
<h2 id="h2-Crypto20Markt20Highlights71640"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐️Afgelopen week zette de algemene trend op de cryptomarkt de recente markttrend voort en zijn korte termijn kleine schommelingen nog steeds de belangrijkste veranderingen. De algehele waarde van de markt is weinig veranderd en het is bijna tijd voor het weekend om te sluiten. Het is onwaarschijnlijk dat de algehele markt op korte termijn grote schommelingen zal ervaren en de kans op het handhaven van een kleine fluctuatie in de toekomst is hoog.</p>
<p>Deze week stond de stijging van de waarde van IP op de cryptomarkt op de eerste plaats onder de mainstream munten. Als een nieuw gelanceerde munt heeft deze munt een grootschalige voortdurende stijging ingeluid. De munt is in een week tijd met ongeveer 110% gestegen en de huidige prijs blijft rond de $3,7, wat een relatief duidelijke voortdurende opwaartse trend laat zien.<br><img src="https://gimg2.gateimg.com/image/article/17401195761.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties701110"><a name="BTC &amp; ETH Wekelijkse Prestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Wekelijkse Prestaties</h2><h3 id="h3-Bitcoin20BTC526964"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/17401195972.jpeg" alt=""><br>(Gegevens met dank aan TradingView)</p>
<p>Deze week vertoonde de prijs van BTC een korte opeenvolgende daling na de opening, die snel daalde naar een wekelijks dieptepunt in de midweek periode, en vervolgens snel steeg naar boven de $95.000. Momenteel bevindt de prijs van BTC zich in een staat van snelle stijging, waarbij de prijs van $98.500 wordt benaderd. De prijs van BTC is het grootste deel van deze week gehandhaafd in het bereik van $95.000-98.000, wat vergelijkbaar is met de prijstrend van vorige week, maar nu is doorbroken naar boven $98.000. Over het algemeen is de waarschijnlijkheid dat BTC op korte termijn doorbreekt naar de $100.000 markt zeer klein, en de waarschijnlijkheid dat het huidige prijsbereik wordt gehandhaafd is relatief hoog.</p>
<h3 id="h3-Ethereum20ETH281733"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17401196203.jpeg" alt=""><br>(gegevens met dank aan TradingView)</p>
<p>Vergeleken met BTC is de prijsverandering van ETH deze week relatief intens, met een grote reeks schommelingen. Na de opening zag de ETH-prijs een ronde van stijgende markt, maar het was van korte duur, gevolgd door een voortdurende daling. Er was een ronde van snelle stijging in het midden van de week, gevolgd door een korte duik. De huidige prijs is over het algemeen stabiel, met een kleine reeks van voortdurende schommelingen. Het hoogtepunt van de ETH-prijs in de week ligt dicht bij $2.820. Verwacht wordt dat er tijdens het weekend een ronde van snelle stijging en daling zal zijn, maar de prijs zal voornamelijk licht stijgen en dalen.</p>
<h2 id="h2-Web320Project20Trend518605"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h2><p>De totale marktwaarde van de zeven soorten projecten fluctueerde deze week, maar de meeste van hen zitten nog steeds in dezelfde ups en downs. De algehele markt werd voornamelijk beïnvloed door de recente marktomstandigheden, en kleine korte termijn ups en downs zijn nog steeds de hoofdtrend.</p>
<table>
<thead>
<tr>
<th>Project Categorie</th>
<th>7d Verandering</th>
<th>Top 3 Stijgers</th>
<th>Reactie</th>
</tr>
</thead>
<tbody>
<tr>
<td>Laag 1</td>
<td>0.3%</td>
<td>EQPAY,MON,IP</td>
<td>De totale marktwaarde van de Layer 1-track bleef klein, met de groei van de topmunten gelijkmatig verdeeld, en geen enkele munt zag een significante toename.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>4.9%</td>
<td>VERTRAGING, KONET, WCO</td>
<td>De trend op de Layer 2-markt liet een zekere stijging zien, maar de stijging van de topmunten bleef binnen een kleine marge, en de algehele verdeling was relatief gelijkmatig.</td>
</tr>
<tr>
<td>Defi</td>
<td>-0.9%</td>
<td>SHAO,MNT,RAMEN</td>
<td>De totale marktwaarde van de DeFi-sector veranderde weinig, maar was over het algemeen in een voortdurende neerwaartse trend, en de topmunten stegen aanzienlijk.</td>
</tr>
<tr>
<td>NFT</td>
<td>0,8%</td>
<td>PAPER, DYP, WOMBAT</td>
<td>De totale waarde van de NFT-markt is licht gestegen, maar de topstijgende munten zijn geconcentreerd in individuele munten, en het algehele traject ontbeert duidelijke opwaartse ondersteuning.</td>
</tr>
<tr>
<td>MEME</td>
<td>-5.4%</td>
<td>PRINTR, CATEX, BEPE</td>
<td>De MEME-muntkoers daalde tot op zekere hoogte, en de stijging van de topmunten bleef boven de 500%, maar de algehele trend is neerwaarts.</td>
</tr>
<tr>
<td>Vloeistof uitzetten</td>
<td>-1.0%</td>
<td>ANKRMATIC, ANKRFTM, STS</td>
<td>Deze sector zag een lichte neerwaartse trend, en de groeicijfers van de topmunten zijn relatief gelijkmatig verdeeld. De lichte daling is voornamelijk te wijten aan de trend van mainstream munten.</td>
</tr>
<tr>
<td>AI</td>
<td>1.5%</td>
<td>WAIFU, CBM, YOKO</td>
<td>De AI-track bleef stijgen, waarbij de topmunten grotere winsten zagen, maar het algemene spoor bevindt zich nog steeds in een herstelfase en de waarschijnlijkheid van een scherpe stijging op korte termijn is relatief klein.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Auteur:<strong>Charles T.</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 beleggingsadvies. 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>