V2VrZWxpamtzIFdlYjMtb25kZXJ6b2Vr772cRGUgbWFya3QgbGlldCBvdmVyIGhldCBhbGdlbWVlbiBlZW4gc3RpamdlbmRlIHRyZW5kIHppZW4=

<p><img src="https://gimg2.gateimg.com/image/article/1746168267weeklyweb3research.png" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht63824"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>Het algehele <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> De cryptomarkt vertoonde deze week een stijgende trend. Beïnvloed door de vermindering van risico’s en de instroom van grote hoeveelheden externe fondsen, zette de cryptomarkt de trend van vorige week voort. Een nieuwe golf van liquiditeit en kapitaalinstroom heeft snel effect. Natuurlijk is er door de publicatie van de Amerikaanse BBP-gegevens een duidelijkere kortetermijndaling geweest, maar de prestaties van de belangrijkste munten blijven sterk.</p>
<p>De mainstream munten op de markt hebben deze week een duidelijke korte termijn opwaartse trend. Naarmate de invloed van recente risicofactoren geleidelijk afneemt en een groot aantal externe ETF-fondsen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> op korte termijn heeft de cryptomarkt opnieuw de $3 biljoen grens doorbroken.</p>
<p>Over het algemeen bevindt de markt zich deze week in een kritieke periode van structurele aanpassing, en de trend van de cryptomarkt in één week kan een signaal worden van de daaropvolgende marktopwarming. De algehele marktrend in één week vertoonde duidelijke intraday ups en downs, en het leidde tot een snelle stijging tegen sluitingstijd.</p>
<p>De prijs van BTC is deze week aanzienlijk gestegen en ligt momenteel rond de $97,000. Dit is weer een stijging nadat de munt onlangs een nieuw hoogtepunt bereikte.</p>
<p>De wekelijkse prijsstijging van ETH is groter dan die van BTC. De huidige prijs van de munt heeft ongeveer $1.850 bereikt. Het is snel gestegen gedurende de dag en heeft het sleutelprijsniveau doorbroken. Het toont momenteel een verdere opwaartse trend.</p>
<p>Deze week bleef de prijstrend van belangrijke mainstream munten de recente opwaartse trend volgen. De totale marktkapitalisatie van de cryptomarkt is aanzienlijk gestegen tot ongeveer $3,02 biljoen, een stijging van ongeveer 2,77% in 24 uur. De huidige prijs van BTC ligt rond de $97.000. De huidige prijs van ETH blijft rond de $1.850.</p>
<p>De algehele cryptomarkt steeg opnieuw deze week, en de structurele aanpassing van de markt begint effect te hebben, terwijl de impact van externe negatieve factoren is verzwakt. De topmunt met de grootste stijging is VIRTUAL, die in een week tijd met ongeveer 134% is gestegen en geprijsd staat op ongeveer $1.71. De recente snelle stijging van deze munt is te wijten aan de liquiditeit van het track vertegenwoordigd door DeFi en de instroom van externe fondsen.</p>
<p>De algehele cryptomarkt zal naar verwachting verder stijgen dit weekend, en de opwaartse trend zal de belangrijkste trend op korte termijn blijven.</p>
<h2 id="h2-Crypto20Markt557577"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥Volgens CoinDesk heeft de Nasdaq-beurs een brief gestuurd naar de U.S. SEC Crypto Working Group, waarin wordt voorgesteld dat toezichthouders digitale activa zorgvuldig classificeren en de regelgevende ‘scheidsrechters’ duidelijk definiëren.</p>
<p>🔥Volgens Decrypt, sinds de vierde halvering van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In april 2024 is de prijs van BTC slechts met 43,4% gestegen, veel lager dan de stijgingen van 7.000%, 291% en 541% die werden geregistreerd na de eerste drie halveringen, wat een record vestigde voor de slechtste prestatie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> na de halvering. Analyse wijst erop dat factoren zoals macro-economische onzekerheid, het handelsbeleid van de regering-Trump, uitstroom van ETF-fondsen en veranderingen in marktstructuur gezamenlijk het opwaartse effect dat door de halvering werd teweeggebracht, hebben verzwakt.</p>
<p>🔥Volgens Coingape voorspelt Citibank in haar laatste rapport dat de totale voorraad stablecoins tegen 2030 zal groeien tot $1,6 biljoen in het basis scenario en tot $3,7 biljoen in het optimistische scenario.</p>
<p>🔥Volgens Techjuice heeft het crypto-project World Liberty Financial (WLFI) van de familie Trump een intentieverklaring ondertekend met de Pakistan Crypto Commission (PCC) om blockchain-innovatie, adoptie van stablecoins en integratie van DeFi in Pakistan te versnellen.</p>
<p>🔥Volgens Reuters werd Nike Inc (NKE.N) op vrijdag aangeklaagd door een groep kopers van Nike-thema NFT’s en andere crypto-activa, waarbij zij beweren dat zij aanzienlijke verliezen hebben geleden nadat het bedrijf plotseling de business unit heeft gesloten die verantwoordelijk was voor het creëren van de bovengenoemde activa.</p>
<p>🔥Volgens Cointelegraph toont het laatste rapport van Deloitte Financial Services Center, een van de ‘Big Four’ accountantskantoren, aan dat de wereldwijde tokenisatiemarkt voor onroerend goed naar verwachting in 2035 $4 biljoen zal bereiken, een aanzienlijke stijging van minder dan $300 miljard in 2024, met een jaarlijkse <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">samenstelling</a> groeipercentage van meer dan 27%.</p>
<p>Volgens Cointelegraph is de marktkapitalisatie van stablecoins in slechts één week met $4,58 miljard gestegen en nadert het de mijlpaal van $240 miljard. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>, USDC, en nieuwe concurrenten zoals USDS en RLUSD blijven de marktgroei stimuleren.</p>
<p>🔥Volgens Cointelegraph is het sentiment op de cryptomarkt deze week hersteld, maar analisten waarschuwen dat zwakke marktliquiditeit en structurele problemen nog steeds prijsschommelingen kunnen veroorzaken, vooral tijdens periodes van verminderde handelsvolume, en de cryptomarkt is nog steeds kwetsbaar voor plotseling macro-economisch nieuws.</p>
<p>🔥Crypto-analist Willy Woo zei dat de fundamentals van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> bullish zijn geworden en kapitaalstromen naar het netwerk toenemen, waardoor goede omstandigheden ontstaan om door historische hoogtepunten te breken.</p>
<p>🔥Volgens Finance Magnates heeft Ripple na jaren van marktspeculatie expliciet ontkend dat het in 2025 een IPO zal lanceren.</p>
<p>🔥Volgens The Block, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2-netwerk Arbitrum Foundation heeft aangekondigd zich terug te trekken uit het door Nvidia gesteunde Ignition AI-acceleratorprogramma omdat de chipgigant heeft verzocht dat de samenwerking niet wordt genoemd in crypto-gerelateerde aankondigingen.</p>
<p>🔥10x Research zei in haar laatste rapport dat de cryptomarkt deze week over de hele linie steeg, waarbij Bitcoin doorbrak naar de $95.000, gedreven door factoren zoals het verlichten van macro-risico’s, recordinstroom van ETF-fondsen en een verzwakkende Amerikaanse dollar.</p>
<p>🔥Volgens CoinGecko-gegevens is het vandaag de 100e dag sinds Trump werd beëdigd en de totale marktkapitalisatie van cryptocurrencies is gestegen naar $3.084 biljoen. Op de dag dat hij officieel aantrad voor zijn tweede termijn (20 januari) bedroeg de totale marktkapitalisatie van cryptocurrencies $3.621 biljoen en is de marktkapitalisatie met $537 miljard verdampt.</p>
<p>🔥Volgens Decrypt toonde CryptoQuant-gegevens aan dat het aanbod van Bitcoin-uitwisselingen daalde naar een zevenjarig dieptepunt, met een daling naar 2.488 miljoen BTC afgelopen vrijdag.</p>
<p>🔥Volgens The Block bereikte op 25 april de 30-daagse Pearson-correlatiecoëfficiënt tussen Bitcoin en goud 0,54, dicht bij het jaarlijkse hoogtepunt van 0,73. Eerder waren de twee in februari ‘ontkoppeld’ en daalde de correlatiecoëfficiënt van 0,73 naar -0,67 in drie weken.</p>
<p>Een nieuwe studie van het Cambridge Centre for Alternative Finance (CCAF) aan de Cambridge Judge Business School aan de Universiteit van Cambridge heeft vastgesteld dat het gebruik van duurzame energie bij Bitcoin-mining is gestegen naar 52,4%, terwijl aardgas steenkool heeft vervangen als de grootste enkele energiebron voor Bitcoin-mining.</p>
<p>🔥Bloomberg Intelligence ETF-analist James Seyffart zei op het X-platform: “Veel mensen hebben gepost/gerapporteerd dat ProShares een zal lanceren <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> futures ETF op 30 april. Maar we hebben bevestigd dat dit niet het g is. Er is nog geen specifieke lanceerdatum, maar we denken dat ze (<a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ETF) zullen lanceren - en het is waarschijnlijk op korte termijn gelanceerd te worden, en het is ook mogelijk op middellange termijn gelanceerd te worden.</p>
<p>Volgens Bitcoin.com, volgens het laatste rapport van Coinshares, wordt verwacht dat de rekencapaciteit van het Bitcoin-netwerk de historische drempel van 1 Zettahash per seconde (ZH/s) zal doorbreken, al in juli van dit jaar, wat aanzienlijk eerder is dan eerder voorspeld.</p>
<p>🔥Eerder onthulde een lid van de cryptogemeenschap dat “een <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> het projectcontract werd vermoedelijk geïmplanteerd met kwaadaardige code door een werknemer, wat resulteerde in een verlies van honderdduizenden dollars.” Thomson, de ontwikkelaar van het DeFi handels- en vermogensbeheerproject QuantMaster, zei dat hij het “slachtoffer van de diefstal” was en met de hulp van SlowMist-oprichter Yu Xian heeft hij de zaak nu succesvol bij de politie gemeld.</p>
<p>🔥Volgens Cointelegraph is het Bitcoin-aandelenverschil tussen BlackRock’s Bitcoin spot ETF “IBIT” en Strategy verkleind tot slechts 20.000 BTC.</p>
<p>🔥Volgens PR Newswire heeft de failliete cryptobeurs FTX en haar liquidatietrust aangekondigd juridische stappen te ondernemen om activa te herstellen, en heeft een rechtszaak aangespannen tegen NFT Stars Limited en KUROSEMI INC (Delysium-operator), waarin zij worden beschuldigd van het weigeren om de gecontracteerde tokens te leveren. FTX zei dat zij vele malen geprobeerd hebben om buitenrechtelijke onderhandelingen te voeren, maar zijn hier niet in geslaagd, en nu contact opnemen met tientallen andere token-uitgevers om activa te herstellen, en juridische maatregelen zullen nemen tegen degenen die weigeren om samen te werken.</p>
<p>🔥Volgens de officiële blog heeft de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Foundation (EF) een nieuwe fase van haar visieverklaring aangekondigd, waarin zij haar missie bevestigt om de openheid, decentralisatie en censuurbestendigheid van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> als een wereldwijd gedeeld computerplatform te handhaven.</p>
<p>🔥Volgens Cointelegraph domineert Grayscale’s GBTC nog steeds qua inkomstengeneratie, met een geschatte jaarlijkse omzet van meer dan $268 miljoen - een cijfer dat hoger is dan de totale omzet van alle andere Bitcoin ETF’s ($211 miljoen), bijna 16 maanden na de lancering van de spot Bitcoin ETF.</p>
<p>🔥Volgens Beincrypto kondigde Itaú, een van de grootste banken in Brazilië, een eerste investering van $210 miljoen aan om Oranje op te richten, een bedrijf dat gespecialiseerd zal zijn in het opbouwen van strategische Bitcoin-reserves.</p>
<p>🔥BlockBeats nieuws, op 1 mei kondigde Ethena Labs aan dat het de luchtdistributie van het derde kwartaal ENA zal uitvoeren, beginnend om 16:00 (UTC) op 1 mei 2025, en 3,5% van de totale ENA-voorraad zal worden verdeeld als beloning voor het derde kwartaal. Er zal geen controleperiode voor de in aanmerking komendeheid zijn en de distributie zal onmiddellijk op 1 mei worden uitgevoerd.</p>
<p>🔥Amerikaanse president Trump praat over handelsovereenkomst: Ik denk dat we het heel goed doen. Eerder nieuws, Amerikaanse president Trump zei dat de tarieven nog niet van kracht zijn.</p>
<p>🔥Volgens de monitoring van Trader T had de Amerikaanse spot Bitcoin ETF op donderdag een nettostroom van $173 miljoen.</p>
<p>🔥Volgens Ptotos heeft de Ethereum Foundation een verklaring uitgegeven waarin de nadruk wordt gelegd op haar op de gemeenschap gerichte bestuur, maar heeft zij nog niet de stemrechten van mede-oprichter Vitalik Buterin bekendgemaakt. Er wordt gemeld dat Laura Shin, auteur van “The Cryptopians”, al vele jaren vraagtekens plaatst bij de vraag of Vitalik Buterin drie superstemmen heeft of dat de stemrechten van de vier bestuursleden hetzelfde zijn.</p>
<p>🔥Robert Mitchnick, hoofd digitale activa bij BlackRock, zei tijdens het Token2049-evenement in Dubai dat Bitcoin ETF-fondsen op grote schaal binnenstromen en de investeringsstructuur verschuift van detailhandel naar instellingen.</p>
<p>Mathew McDermott, hoofd digitale activa bij Goldman Sachs, zei op de Token2049-conferentie dat duidelijke regelgeving het gemakkelijker zal maken voor grote instellingen om kapitaal in het cryptoveld in te zetten en de grootschalige ontwikkeling ervan te bevorderen.</p>
<p>🔥Volgens analisten van CryptoQuant heeft de marktkapitalisatie van Bitcoin $882.228 miljard bereikt, een recordhoogte.</p>
<p>🔥Het aantal ADP-banen in de Verenigde Staten steeg in april met 62.000, de kleinste stijging sinds juli 2024, aanzienlijk lager dan verwacht. Het verwachte aantal was 115.000, en de vorige waarde was 155.000.</p>
<p>🔥De initiële waarde van het geannualiseerde kwartaalpercentage van het reële bbp in het eerste kwartaal van de Verenigde Staten was -0,3%, een nieuw dieptepunt sinds het tweede kwartaal van 2022. Na de publicatie van de bbp-gegevens werd de daling van de futures van de Amerikaanse aandelenindex uitgebreid, met Nasdaq 100 futures die met 1,4% daalden, Dow futures met 0,45% en S&amp;P 500 futures die met 0,96% daalden. BTC daalde op korte termijn onder $94.500.</p>
<p>PANews meldde op 1 mei dat volgens gegevens van SoSoValue, de totale nettoutstroom van Bitcoin spot ETF’s op 30 april, Eastern Time $56.2336 miljoen bedroeg.</p>
<p>🔥PANews meldde op 1 mei dat volgens de SoSoValue-gegevens de totale nettostroom van Bitcoin spot ETF’s op 30 april, Eastern Time $56.2336 miljoen bedroeg.</p>
<h2 id="h2-Regelgeving20amp20Macrobeleid202173"><a name="Regelgeving &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgeving &amp; Macrobeleid</h2><p>🔥Volgens de Bitcoin-wetgeving zullen de twee Bitcoin-reservewetsvoorstellen van Arizona nu voor de derde keer worden gelezen op aankomende maandag en kunnen ze worden gestemd. Dit kan het eerste Bitcoin-reservewetsvoorstel op staatsniveau worden dat wordt aangenomen bij een stemming.</p>
<p>🔥Volgens Cointelegraph verklaarde Hester Peirce, een lid van de U.S. Securities and Exchange Commission (SEC) en hoofd van de Crypto Asset Working Group, tijdens de ‘Know Your Custodian’ ronde van de SEC dat de huidige regelgeving voor crypto-activa in de VS lijkt op het spel ‘de vloer is lava’ in het donker, en geregistreerde instellingen gedwongen worden voorzichtig te handelen onder onduidelijke regels en direct contact met crypto-activa te vermijden.</p>
<p>🔥Volgens Jiemian News kondigden de UAE International Holding Company (IHC), het soevereine wealth fund Abu Dhabi Development Holding Company (ADQ) en de First Abu Dhabi Bank (FAB) op 28 april aan plannen te hebben om een nieuwe stablecoin te lanceren, gedekt door de UAE-dirham. De stablecoin zal volledig gereguleerd worden door de UAE Central Bank en uitgegeven worden door FAB, de grootste bank in de VAE.</p>
<p>🔥Volgens Cointelegraph heeft de senator van Massachusetts, Elizabeth Warren, overheidsfunctionarissen opgeroepen om kwesties met betrekking tot de Meme-munt van de Amerikaanse president Trump en zijn mediabedrijf aan te pakken. Warren en Adam Schiff hebben gezamenlijk een brief geschreven aan het Bureau voor Overheidsethiek waarin zij een onderzoek vragen naar de morele risico’s die kunnen worden veroorzaakt door Trump’s Meme-munt TRUMP.</p>
<p>🔥Volgens The Block heeft de wetgevende vergadering van de staat Arizona de Strategic Bitcoin Reserve Act SB 1025 aangenomen, waarbij het ministerie van financiën van de staat en het pensioenstelsel worden gemachtigd om tot 10% van de beschikbare fondsen te investeren in digitale activa zoals Bitcoin.</p>
<p>🔥BlockBeats nieuws, op 1 mei, volgens Cointelegraph, heeft het Huis van Afgevaardigden van North Carolina het Digital Asset Investment Act (HB 92) aangenomen met 71 stemmen voor en 44 stemmen tegen, waardoor de staatspenningmeester tot 5% van de staatsfondsen mag investeren in goedgekeurde cryptocurrencies. Het wetsvoorstel is nu ingediend bij de staats Senaat ter overweging.</p>
<h2 id="h2-Crypto20Markt20Highlights682588"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐️In de afgelopen week heeft de cryptomarkt als geheel een voortdurende opwaartse trend laten zien. Door het geleidelijke vervagen van externe negatieve factoren en de snelle instroom van externe fondsen, zijn de algehele marktvloeibaarheid en kapitaalomvang blijven toenemen, en heeft de structurele aanpassing van de cryptomarkt verder een positieve en redelijke trend getoond. In de afgelopen week zijn de belangrijkste munten voornamelijk op korte termijn gestegen en gedaald binnen de dag. Over het algemeen is de opwaartse trend duidelijker. Op dit moment is het waarschijnlijk dat de markt een voortdurende opleving zal zien.</p>
<p>⭐️Deze week stond de stijging van VIRTUAL op de cryptomarkt op de eerste plaats onder de belangrijkste munten, met een stijging van ongeveer 134%, voornamelijk als gevolg van de recente snelle instroom van DeFi-liquiditeit en fondsen, evenals de invloed van de marktactie van het protocol zelf. Op dit moment staat de prijs van VIRTUAL op een recent hoogtepunt, met een waarde van ongeveer $1,7, en het wekelijkse hoogtepunt ligt rond de $1,77. Het bevindt zich momenteel in een kortetermijnvolatiele trend, en de daaropvolgende prijs kan verdere veranderingen met zich meebrengen.<br><img src="https://gimg2.gateimg.com/image/article/17461685991.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties843723"><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-Bitcoin20BTC673659"><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/17461686292.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>Deze week, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC prijs</a> trend vertoonde voortdurende intraday ups en downs na de opening, en de prijs bleef in het bereik van $93.000-$95.000. Nabij het sluitingstijdstip van het weekend, beïnvloed door recente algehele factoren, vertoonde de prijs een voortdurende compenserende stijgende trend, rechtstreeks doorbreken van de sleutelprijs van $95.000, en vervolgens verder doorbreken naar boven $97.000. De BTC-prijs bereikte een recent hoogtepunt, en de algehele marktomstandigheden zijn ook aanzienlijk hersteld. Op korte termijn is het waarschijnlijk dat de BTC-prijs opwaarts blijft in de korte termijn, en blijven ups en downs in een kleine range zal nog steeds de mainstream markt zijn.</p>
<h3 id="h3-Ethereum20ETH712955"><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/17461686493.jpeg" alt=""><br>(Data Met Dank Aan TradingView)</p>
<p>De prijstrend van ETH deze week is iets hoger dan die van BTC, maar de twee trends zijn consistent. ETH’s prijs piekte boven de $1.800 in een week. Momenteel blijft de prijs van ETH rond de $1.850 en de daaropvolgende trend zal waarschijnlijk voornamelijk een ronde van compensatoire verhogingen zijn, met een grote opwaartse ruimte.</p>
<h2 id="h2-Web320Project20Trend383080"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h2><p>De totale marktkapitalisatie van de zeven soorten projecten steeg deze week over de hele linie, maar de meeste stijgingen bleven binnen een kleine marge. De markt zette zijn recente opwaartse trend voort als gevolg van verschillende factoren, maar de opwaartse beweging van de meeste koersen was beperkt. Verwacht wordt dat de huidige belangrijkste markttrend zal aanhouden tijdens de weekendafsluiting.</p>
<table>
<thead>
<tr>
<th>Project Categorie</th>
<th>7d Verandering</th>
<th>Top 3 Stijgers</th>
<th>Opmerking</th>
</tr>
</thead>
<tbody>
<tr>
<td>Laag 1</td>
<td>3.0%</td>
<td>DEC,PICA,PRIVIX</td>
<td>De totale marktkapitalisatie van de Layer 1 track is gestegen. De stijging van de topmunten is niet gelijkmatig verdeeld, met een grote stijging in individuele munten als belangrijkste focus.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>3.3%</td>
<td>BB, LAI, HACD</td>
<td>De Layer 2-sector zette zijn opwaartse trend voort, maar de algehele stijging was klein, en de winsten van de topmunten waren geconcentreerd in individuele munten.</td>
</tr>
<tr>
<td>DeFi</td>
<td>3.5%</td>
<td>COMBO,ANY,CVP</td>
<td>De totale marktkapitalisatie van de DeFi-sector is gestegen, en de winsten van de topmunten zijn geconcentreerd in individuele munten. De algehele groeitrend is afgenomen.</td>
</tr>
<tr>
<td>NFT</td>
<td>6.7%</td>
<td>OIK,XNL,GHX</td>
<td>De totale waarde van de NFT-markt bleef stijgen, maar de algehele omvang was lager dan vorige week, en de algehele verdeling van de stijging was nog steeds relatief gelijkmatig.</td>
</tr>
<tr>
<td>MEME</td>
<td>3.7%</td>
<td>HOL,CATX,BANKS</td>
<td>De MEME coin track heeft een zekere mate van stijging ervaren, die geconcentreerd is in de topindividuele munten, en de verdeling is relatief ongelijk.</td>
</tr>
<tr>
<td>Vloeistof uitzetten</td>
<td>2.3%</td>
<td>X33,OS,STS</td>
<td>Deze sector liet een lichte stijging zien, waarbij de winsten van de topmunten relatief gelijkmatig werden verdeeld. Vergeleken met andere tracks zijn de winsten eigenlijk vrij beperkt.</td>
</tr>
<tr>
<td>AI</td>
<td>11.4%</td>
<td>H4CK,SENT,AGORA</td>
<td>De AI-track zag een scherpe stijging, voornamelijk als gevolg van de recente ontwikkelingen in AI-gerelateerde industrieën. Andere munten in de algehele track hebben ook relatief grote stijgingen gezien.</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 enkele beleggingssuggestie. 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>