V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIA==

2025-04-04, 07:51

<p><img src="https://gimg2.gateimg.com/image/article/1743752349weeklyweb3research.png" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht265030"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>De <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> werd deze week sterk beïnvloed door externe factoren. Het tariefbeleid van Trump trad in werking, de kapitaalrisico-aversie nam toe en de Amerikaanse aandelenmarkt legde grote druk op de cryptomarkt, waardoor de algehele markt sinds afgelopen weekend een voortdurende neerwaartse trend vertoonde. Er waren ook geen tekenen van herstel na de opening en de algehele neerwaartse trend was zeer duidelijk.</p>
<p>Deze week vertoonden mainstream munten op de markt een algemene daling. Vanwege de daling van de Amerikaanse aandelen werden beursgenoteerde bedrijven in de cryptosector ernstig beïnvloed, en de twee trends waren behoorlijk vergelijkbaar. Bovendien heeft de impact van de aanpassing van de tarieven door de Amerikaanse overheid en het crypto-gerelateerde beleid een zekere klap toegebracht aan de markt. De cryptomarkt heeft nog steeds een grote neerwaartse trend op korte termijn.</p>
<p>De markt heeft sinds de opening van deze week een voortdurende neerwaartse trend doorgemaakt, en sommige mainstream munten zijn in een week met 30% gedaald. Echter, na het ingaan van de mid-week periode hebben sommige mainstream munten een lichte hersteltrend gehad, voornamelijk als gevolg van het nieuws, maar deze trend heeft niet voortgezet. Naarmate de markt de sluitingsperiode van de week nadert, vertoont de algehele markt nog steeds een kortetermijn neerwaartse trend, en er bestaat een mogelijkheid van verdere daling in de toekomst.</p>
<p>De prijs van BTC is deze week gedaald en heeft nu het sleutelprijsondersteuningsniveau van ongeveer $81,500 bereikt. Als het onder het huidige prijsbereik daalt, is er een grote kans op een compenserende daling. Er is een bepaalde kans dat het onder de $80,000 zal dalen.</p>
<p>ETH’s wekelijkse prijstrend is vergelijkbaar met die van BTC en vertoont momenteel een kortetermijndalende trend. De wekelijkse hoogste prijs ligt rond $1.941. Het is nu de wekelijkse laagste prijsklasse binnengegaan, met een niveau van ongeveer $1.760. De algehele prijsdaling is groter dan die van BTC.</p>
<p>De prijstrend van belangrijke mainstream munten deze week is voornamelijk neerwaarts. De totale marktkapitalisatie van de huidige cryptomarkt is aanzienlijk gedaald, met ongeveer $2,6 biljoen, een daling van ongeveer 5,3% in 24 uur. De huidige prijs van BTC ligt rond de $81.700. De huidige prijs van ETH blijft rond de $1.760.</p>
<p>Deze week zat de algehele cryptomarkt in een volatiele neerwaartse trend, waarbij de meeste mainstream munten een neerwaartse trend vertoonden. Een paar prijzen stegen, maar de stijging was relatief klein. <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a> was de topmunt met de grootste stijging, die in ongeveer een week tijd ongeveer 43% bereikte. Dit kwam voornamelijk doordat het als een blockchain utility-munt recentelijk merkherpositionering en stakingincentives promootte, waardoor de muntkoers op korte termijn steeg.</p>
<p>De cryptomarkt zal dit weekend blijven schommelen, en korte termijn schommelingen zullen de hoofdstroom van de markt zijn. De stijging en daling van belangrijke munten zal afhangen van of de leidende munten een compenserende daling laten zien.</p>
<h2 id="h2-Cryptomarkt507972"><a name="Cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptomarkt</h2><p>🔥Volgens Samaa verklaarde de financiële marktstrateeg van Exness Inky Cho dat de recente daling op de cryptomarkt mogelijk verband houdt met de paniekverkoop veroorzaakt door de schuldaflossing van Mt.Gox en de overdracht van BTC. Tegelijkertijd hebben Trump’s opmerkingen over de dreigende economische recessie de aandelen- en cryptomarkten geschokt.</p>
<p>🔥Volgens nieuws. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>, in de 89 dagen sinds het binnengaan van 2025, is de totale waarde van het cryptoveld met meer dan $600 miljard gekrompen, van ongeveer $32,700 naar ongeveer $2.6 biljoen.</p>
<p>🔥Volgens Cointelegraph is de handelsvolume van de top tien stablecoins gedaald tot een kwart van het niveau van de bullmarkt cyclus in december vorig jaar. Analisten geloven dat handelaarsmoeheid, regelgevingsonzekerheid en het aanbod van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> dat een zevenjarig dieptepunt heeft bereikt, belangrijke factoren zijn.</p>
<p>🔥Peter Schiff, een econoom die onvriendelijk staat tegenover cryptocurrencies, plaatste op het X-platform dat de goudprijs opnieuw een recordhoogte heeft bereikt van meer dan $3,080 per ounce, terwijl miljoenen jonge Amerikanen deze “hogesnelheidstrein” aan zich voorbij hebben laten gaan en hun aandacht hebben verlegd naar Bitcoin.</p>
<p>🔥Greeks.live analist Adam zei dat groepsleden over het algemeen voorzichtig zijn om bearish te zijn. Handelaren richten zich op het verkopen van putopties op $81.000 als mogelijke bodem. Momenteel heeft <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> een negatieve financieringsrente en is de volatiliteitsindicator DVOL gestegen, wat wijst op toenemende marktonzekerheid.</p>
<p>🔥Volgens Cryptoslate, volgens een recent rapport van onderzoeksbureau Gedecentraliseerd, is er te midden van een stijging in het aantal tokens een stagnatie van nieuwe kapitaalinstroom, waardoor veel cryptoprojecten ondergefinancierd zijn.</p>
<p>🔥Crypto-analist Ali Martinez publiceerde een grafiekanalyse op het X-platform waarin stond dat de BTC-verkopersratio is gedaald naar 0,086%. In de afgelopen twee jaar heeft een verkopersratio onder 0,1% meestal een scherpe opleving in de prijzen aangekondigd.</p>
<p>🔥Volgens Zuid-Koreaanse media SBS is het totale aantal gebruikers van virtuele activa-uitwisselingen in Zuid-Korea eind februari van dit jaar de 16 miljoen overschreden, met een totaal van 16,29 miljoen, wat overeenkomt met ongeveer 32% van de totale bevolking van het land (ongeveer 51,68 miljoen).</p>
<p>🔥Volgens TheBlock steeg het dagelijkse handelsvolume van cryptocurrencies na de Amerikaanse verkiezingen op 5 november naar $126 miljard te midden van een grote marktenthousiasme en actieve speculatie. Het is nu gedaald tot $35 miljard, ongeveer 70% lager dan het hoogtepunt, en is teruggekeerd naar het niveau van voor de verkiezingen. Recentelijk aangekondigde tarieven tegen belangrijke Amerikaanse handelspartners hebben onzekerheid met zich meegebracht, waardoor het handelsenthousiasme zowel in de traditionele als in de cryptomarkten is afgenomen.</p>
<p>🔥Volgens Cointelegraph zei David Pakman, managing partner van CoinFund, dat de wereldwijde stablecoinvoorraad zou kunnen stijgen van de huidige omvang van ongeveer $225 miljard naar $1 biljoen, wat een belangrijke katalysator zou kunnen worden voor de groei van de cryptomarkt.</p>
<p>🔥Volgens Benzinga zei Matt Mena, een crypto-onderzoeksstrateeg bij 21Shares, dat terwijl de Amerikaanse aandelen schommelden te midden van macro-onzekerheid, BTC veerkracht heeft getoond en het ondersteuningsgebied van $84.000-85.000 verdedigt. Nic Puckrin, oprichter van The Coin Bureau, wees erop dat de PCE-gegevens die op vrijdag zijn vrijgegeven, de Federal Reserve ertoe zouden kunnen brengen om zijn recente plannen voor renteverlaging uit te stellen. Er wordt niet verwacht dat Bitcoin terugkeert naar zijn historische hoogtepunten totdat de Fed opnieuw de rente verlaagt.</p>
<p>🔥Volgens CoinDesk schreef Elliot Chun, partner bij Architect Partners, in een marktobservatierapport: ‘Door verschillende strategische inrichtingen te combineren, wordt voorspeld dat tegen 2030 25% van de bedrijven in de S&amp;P 500-index Bitcoin zal opnemen als een langetermijnactivum op hun balans.’</p>
<p>🔥Volgens Decrypt, op 30 maart, tijdens een stadsvergadering georganiseerd door Musks America PAC in Green Bay, Wisconsin, distantieerde Musk het Department of Federal Efficiency (D.O.G.E.) van de <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> cryptocurrency.</p>
<p>🔥Volgens Beincrypto beweerde BlackRock CEO Larry Fink in een recente brief dat Bitcoin en cryptocurrency’s de internationale status van de Amerikaanse dollar zouden kunnen ondermijnen. Als investeerders Bitcoin zien als een hedge tegen inflatie van de Amerikaanse dollar, zou dit ernstige problemen kunnen veroorzaken.</p>
<p>🔥Volgens 10x Research werd de rally van Bitcoin in de afgelopen drie weken gefrustreerd door hoger dan verwachte kern PCE-gegevens, die wijzen op stijgende inflatie, mede veroorzaakt door het tariefbeleid van Trump, dat het consumentenvertrouwen verzwakte.</p>
<p>🔥 Volgens The Block lanceert Miller Whitehouse-Levine, een langdurige crypto-supporter, zijn volgende onderneming in Washington, D.C. - de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Policy Institute om wetgevers en regelgevers op te leiden om ‘verder dan Bitcoin’ te denken. De non-partijgebonden non-profitorganisatie maakte maandag officieel haar debuut, nu digitale activa de aandacht van wetgevers trekken en gerelateerde wetgeving snel vordert (met betrekking tot alles, van stablecoins tot marktstructuur).</p>
<p>Toen World Liberty Financial meer dan $500 miljoen ophaalde, wezen experts uit de industrie erop dat de familie van voormalig Amerikaans president Donald Trump de controle over de cryptobusiness overnam en het grootste deel van het geld greep, dankzij governancevoorwaarden die insiders voortrokken, volgens Reuters.</p>
<p>🔥Forbes heeft de 39e Global Billionaires List uitgebracht. Het aantal miljardairs ter wereld heeft voor het eerst de 3.000 overschreden en bereikte 3.028, met een totale rijkdom van $16,1 biljoen, een stijging van $2 biljoen ten opzichte van vorig jaar. Uit de lijst blijkt dat 15 miljardairs een nettowaarde van meer dan $100 miljard hebben, waarbij Elon Musk met $342 miljard de titel van rijkste man ter wereld heroverde, gevolgd door Mark Zuckerberg ($216 miljard) en Jeff Bezos ($215 miljard). Daarnaast staan er in totaal 16 miljardairs in de crypto-sector op de lijst, met een totale rijkdom van meer dan $164 miljard en een gemiddelde nettowaarde van $6,8 miljard.</p>
<p>🔥Volgens de monitoringinformatie van ElonsX heeft Musk zojuist het account van mede-oprichter Wang Chun van F2Pool toegevoegd op het X-platform. Eerder nieuws, mede-oprichter van F2Pool, Wang Chun, zal een vierdaagse SpaceX-orbitale vlucht leiden.</p>
<p>🔥Volgens de aankondiging van de Hong Kong Stock Exchange heeft Zhongzefeng, een aan de beurs genoteerd bedrijf in Hong Kong, de jaarlijkse prestatieaankondiging voor 2024 vrijgegeven, waarin werd onthuld dat haar dochteronderneming Atlantic Asset Management Co., Ltd. door de Securities and Futures Commission in Hong Kong is goedgekeurd om de door Zhongzefeng beheerde fondsen toe te staan om niet meer dan 10% van hun beheerde activa (AUM) te investeren in virtuele activa. Daarnaast werd in de aankondiging ook onthuld dat de fondsen van Zhongzefeng zich het komende jaar zullen richten op wereldwijde aandelen, futures en opties, met inbegrip van gebieden zoals indices, cryptocurrencies, enz.</p>
<p>🔥Het in Japan genoteerde bedrijf Metaplanet heeft aangekondigd dat het 1,998 miljard yen (ongeveer $13,34 miljoen) zal besteden om zijn bezit van 160 bitcoins te vergroten, waardoor het totale Bitcoin-bezit op 4.206 BTC komt.</p>
<p>Elon Musk’s X-platform dringt er bij het Amerikaanse Hooggerechtshof op aan om bedrijven te beschermen tegen dagvaardingen die zijn uitgevaardigd door federale wetshandhavingsinstanties ‘zonder redelijke verdenking’, om te voorkomen dat ze gedwongen worden gevoelige financiële gegevens van gebruikers bekend te maken, zo meldt Bloomberg.</p>
<p>🔥Volgens DL News heeft de wereldwijde vermogensbeheergigant BlackRock goedkeuring gekregen van de UK Financial Conduct Authority (FCA) en is officieel een geregistreerd crypto-activabedrijf geworden.</p>
<p>🔥VANECK heeft de VANECK geregistreerd <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ETF in Delaware, which indicates that the company may launch a <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a>-based investment product in the United States.</p>
<p>🔥Volgens Decrypt zei JPMorgan in een rapport op dinsdag dat Bitcoin-mijnwerkers blijven worstelen, en de 14 genoteerde mijnbouwbedrijven in het veld hebben gezamenlijk de slechtste maand ooit meegemaakt in maart.</p>
<p>🔥Volgens CoinDesk zei Zach Pandl, onderzoeksdirecteur bij Grayscale, dat het effect van tarieven op cryptocurrencies mogelijk al “ingeprijsd” is en het ergste voorbij zou kunnen zijn.</p>
<p>🔥Layer1 blockchain Shardeum heeft officieel aangekondigd dat zijn wereldwijd eerste op EVM-gebaseerde automatische uitbreidingsblockchain mainnet op 15 april 2025 officieel zal worden gelanceerd. Eerder nieuws, Shardeum lanceerde een airdrop-evenement vóór de lancering van het mainnet, en de airdrop-registratie is nu online.</p>
<p>🔥Volgens Cointelegraph is de belangrijkste inkomstenbron voor de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk van de Layer 2-uitbreidingsketen - “Blob-kosten” - is gedaald naar het laagste wekelijkse niveau van dit jaar.</p>
<p>🔥RootData-gegevens tonen aan dat het totale financieringsbedrag van de cryptomarkt in maart 2025 $2,883 miljard bedroeg, een stijging van 153% ten opzichte van $1,139 miljard in maart 2024 en 198% ten opzichte van $967 miljoen in februari 2025. Bovendien was het aantal financieringen in maart 2025 74, een daling van 28,8% ten opzichte van 104 in februari. Wat betreft het totale financieringsbedrag van de sector, zijn de top drie sectoren andere categorieën, Cefi en Defi.</p>
<p>🔥Volgens The Block kondigde videogameverkoper GameStop dinsdag aan dat het $1.5 miljard zou ophalen via een private plaatsing van converteerbare obligaties, en van plan was om de opbrengst te gebruiken om Bitcoin te kopen.</p>
<p>🔥AI-infrastructuurprotocol Cambrian Network heeft aangekondigd dat het een financieringsronde van $5,9 miljoen heeft afgerond, geleid door a16z Crypto Startup Accelerator (CSX) en deelgenomen door BB Fund.</p>
<p>🔥Volgens Bloomberg daalden de prijzen van Bitcoin en andere belangrijke cryptocurrencies nadat de Amerikaanse president Trump tarieven had opgelegd aan Amerikaanse handelspartners wereldwijd, wat leidde tot een duik in risicovolle activa.</p>
<p>🔥Volgens CoinDesk bereikte het gemiddelde dagelijkse handelsvolume van crypto-derivaten van de Chicago Mercantile Exchange Group (CME) in het eerste kwartaal van 2025 198.000 contracten, met een nominale waarde van $11,3 miljard, een recordhoogte.</p>
<p><a href="/price/mask-network-mask" target="_blank" class="blog_inner_link">Mask Network</a> oprichter Suji Yan zei op het X-platform: “Het team heeft de plotselinge daling van de recente prijs van MASK opgemerkt en werkt hard om meer informatie/details te krijgen. De oplossing zal binnen 1-2 dagen worden aangekondigd.”</p>
<p>🔥Volgens The Block is Standard Chartered Bank begonnen met onderzoeksdekking over de Layer1 blockchain <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> en zei dat het verwacht dat de inheemse token AVAX van het netwerk meer dan 10 keer zal stijgen van de huidige prijs van ongeveer $20 tot $250 tegen het einde van 2029.</p>
<p>🔥Volgens The Block heeft het token-uitgifteplatform CoinList aangekondigd dat het voor het eerst sinds 2019 terugkeert naar de Amerikaanse markt en een tokenverkoop zal houden voor de DoubleZero Foundation, het team achter het DoubleZero-protocol. Het token, genaamd 2Z, zal open zijn voor gekwalificeerde Amerikaanse investeerders. Dit markeert de eerste keer in vijf jaar dat CoinList Amerikaanse investeerders toestaat deel te nemen aan tokenverkopen.</p>
<p>🔥Volgens CoinDesk heeft de Britse dochteronderneming van het bedrijf voor financiële dienstverlening op het gebied van digitale activa, Galaxy Digital, aangekondigd dat haar aanvraag voor een handelsvergunning voor derivaten van de Britse Financial Conduct Authority (FCA) officieel is goedgekeurd.</p>
<p>🔥Bitcoin-ontwikkelaar Ruben Somsen plaatste op het X-platform dat Google de mailinglijst van de Bitcoin-ontwikkelingsgroep BitcoinDev ‘permanent heeft verwijderd’. Ruben zei eerder: ‘Voor zover ik weet is er geen ongepaste inhoud geplaatst’.</p>
<p>🔥Volgens CoinDesk heeft Fidelity officieel een kosteloze crypto IRA-pensioenrekening gelanceerd. Via dit plan kunnen gebruikers ouder dan 18 jaar in de Verenigde Staten investeren in Bitcoin, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> Fidelity beheert de activa en slaat ze op in koude portefeuilles. Het product ondersteunt Roth, traditionele en rollende IRA’s, waarmee wordt voldaan aan de sterke vraag van klanten naar belastingvriendelijke cryptoinvesteringskanalen.</p>
<h2 id="h2-Regelgeving20amp20Macrobeleid442378"><a name="Regelgeving &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgeving &amp; Macrobeleid</h2><p>🔥 Volgens Cryptoslate heeft Panama een uitgebreid wetsvoorstel gepubliceerd om cryptocurrencies te reguleren en de ontwikkeling van blockchainservices te bevorderen.</p>
<p>🔥Volgens Decrypt heeft de Amerikaanse Federal Deposit Insurance Corporation (FDIC) aangekondigd dat banken zich kunnen bezighouden met cryptocurrencies en andere wettelijk toegestane activiteiten zonder voorafgaande goedkeuring van toezichthouders, mits ze de risico’s goed kunnen beheren. Deze beleidswijziging trekt een vereiste van 2022 in dat FDIC-toezichthouders vereiste om het agentschap op de hoogte te stellen voordat ze zich bezighielden met crypto-gerelateerde activiteiten. Onder de nieuwe richtlijnen kunnen banken diensten aanbieden die verband houden met digitale activa zonder voorafgaande toestemming van het agentschap.</p>
<p>🔥Volgens de Hong Kong Wen Wei Po zei Chen Weimin, plaatsvervangend hoofduitvoerend directeur van de Monetaire Autoriteit van Hong Kong, dat er een regelgevend kader wordt opgesteld voor de uitgifte van stablecoins om de basis te leggen voor de ontwikkeling van het cryptosysteem. Hong Kong heeft goede vooruitgang geboekt bij de ontwikkeling van stablecoins, en het relevante wetsvoorstel wordt beoordeeld door de Wetgevende Raad en naar verwachting de komende maanden aangenomen.</p>
<p>🔥Volgens Eleanor Terrett, de aankomende voorzitter van de U.S. Commodity Futures Trading Commission (CFTC), is Brian Quintenz begonnen met gesprekken met senatoren op Capitol Hill om zich voor te bereiden op zijn benoemingshoorzitting. Vandaag ontmoette hij Chuck Grassley, een Republikeinse senator uit Iowa en lid van de Senaatscommissie voor Landbouw, om CFTC-zaken te bespreken, waaronder de regulering van de cryptospotmarkt.</p>
<p>🔥Volgens Bitcoin.com heeft Hester Peirce, een lid van de U.S. Securities and Exchange Commission (SEC), het Congres opgeroepen om de cryptoregulering te vereenvoudigen en de regelgevingsverwarring te verminderen tijdens de 8e Blockchain Summit van de Chamber of Digital Commerce in Washington, DC, op 26 maart.</p>
<p>🔥Volgens cryptojournalist Eleanor Terrett onthulde Bryan Steil, voorzitter van de U.S. House of Representatives Digital Assets Subcommittee, dat na de besprekingen van woensdag de STABLE Act van het Huis van Afgevaardigden van de Verenigde Staten (Stablecoin Transparency and Accountability for a Better Ledger Economy Act) ‘goed is afgestemd op de GENIUS Act van de Senaat (Guidance and Establishment of the United States Stablecoin National Innovation Act)’, wat werd bereikt na verschillende rondes van ‘conceptrevisies’ in het Huis en de Senaat en technische bijstand van de SEC en CFTC.</p>
<p>🔥Volgens CoinDesk heeft de Braziliaanse Nationale Monetaire Raad (CMN) Resolutie 5 uitgevaardigd.202⁄2025, waarbij gesloten pensioenfondsen zoals Entidades Fechadas de Previdência Complementar (EFPC’s) verboden worden om hun gegarandeerde reserves te investeren in Bitcoin (BTC) of andere crypto-activa omdat cryptocurrencies als te risicovol worden beschouwd.</p>
<p>🔥Volgens Bitcoin.com heeft de Nigeriaanse Investerings- en Effectenwet (ISA) 2025, recent ondertekend door de Nigeriaanse president Bola Ahmed Tinubu, effectief een einde gemaakt aan de onzekerheid over de status van cryptocurrencies, en heeft de nieuwe wet eigenlijk de Investerings- en Effectenwet Nr. 29 van 2007 ingetrokken. Deze herziene effectenwet erkent ‘officieel’ cryptocurrency als een activaklasse.</p>
<p>🔥Volgens People’s Finance zei Li Chunlin, plaatsvervangend directeur van de Nationale Ontwikkelings- en Hervormingscommissie, op 2 april tijdens een persconferentie van het Staatspersbureau voor Informatie van de Staatsraad dat de Nationale Ontwikkelings- en Hervormingscommissie nieuwe technologieën zoals privacy computing heeft toegepast om het delen en gebruik van kredietinformatie te versterken, met als doel het risico op informatie lekken te verminderen. Tegelijkertijd zal het de toepassing van blockchaintechnologie verkennen om de ‘ketting’ van belangrijke gegevens te bevorderen, gegevensversleuteling te realiseren en verwerkingsplasticiteit te bewerkstelligen.</p>
<p>🔥Volgens Bitcoin Magazine is Texas House Bill 4258 (H.B. 4258) vandaag ingediend bij de Government Efficiency utive Committee ter beoordeling. De wet machtigt de staatsaccountant om tot $250 miljoen te investeren in Bitcoin, en machtigt ook gemeenten of provincies om tot $10 miljoen van hun gelden of fondsen onder hun controle te investeren in Bitcoin en/of andere cryptocurrencies.</p>
<p>🔥Volgens het door de National Cryptocurrency Association (NCA) in opdracht gegeven en door The Harris Poll uitgebrachte “2025 U.S. Crypto Holders Report” houdt ongeveer 21% van de volwassenen in de Verenigde Staten (ongeveer 55 miljoen mensen) cryptocurrencies aan, waarvan 76% aangeeft dat crypto-activa een positieve invloed hebben op hun leven.</p>
<h2 id="h2-Crypto20Markt20Highlights637424"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐️Afgelopen week is de algehele cryptomarkt gedaald en blijft de markt de neerwaartse trend van Amerikaanse aandelen volgen, met een aanzienlijke daling. In de afgelopen week zijn de meeste mainstream munten gedaald en heeft slechts een klein aantal munten een stijgende trend laten zien. De markt blijft fluctueren en dalen, en het wordt verwacht dat er in de toekomst een ronde van grotere marktschommelingen zal zijn.</p>
<p>⭐️Deze week stond <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> op de eerste plaats onder mainstream munten wat groei betreft, met een stijging van ongeveer 43%. Dit komt voornamelijk doordat de munt onlangs verschillende vormen van platformdynamiek heeft gepromoot, zoals merkhervorming en stakingsstimulansen. De gemeenschap heeft recent enthousiast gereageerd, wat gezamenlijk heeft bijgedragen aan de relatief duidelijke opwaartse trend van de munt. Het is een van de weinige mainstream munten die binnen een week een grote opwaartse trend heeft weten te realiseren. De huidige <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS prijs</a> blijft rond $0,82, met een wekelijkse hoogtepunt van $0,85. Het bevindt zich momenteel in een kortetermijnfluctuatietrend en de prijs heeft een lichte correctie.<br><img src="https://gimg2.gateimg.com/image/article/17437525981.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties129725"><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-Bitcoin20BTC334933"><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/17437527782.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 een korte termijn oscillatietrend na de opening, en handhaafde een kleine range van intraday schommelingen. De algehele prijs ging een ronde van kleine stijgingen in, maar daarna was er een duik, en de prijs daalde snel van een hoogtepunt van $88.000 naar een range van $82.000. De algehele cryptomarkt bleef volgen terwijl de Amerikaanse aandelenmarkt een snelle daling doormaakte. De BTC-prijs toonde voornamelijk een stevig prijsondersteuningsniveau. In de toekomst zal de BTC-prijs blijven volgen de algehele trend van de markt, en het optreden van een compenserende daling kan niet worden uitgesloten.</p>
<h3 id="h3-Ethereum20ETH506799"><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/17437528043.jpeg" alt=""><br>(Data Met Dank Aan TradingView)</p>
<p>De prijstrend van ETH deze week is consistent met BTC, maar de daling is groter dan BTC en het wordt verwacht dat het opnieuw zal dalen. De prijs van ETH piekte op $1.950 binnen een week, maar daalde vervolgens snel binnen een dag. Momenteel, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> blijft rond de $1.750-$1.800 en blijft schommelen. De prijs heeft rond de $1.780 bereikt. Er wordt verwacht dat er tijdens het weekend een nieuwe ronde van prijsschommelingen zal zijn, en er bestaat een mogelijkheid van een lichte daling opnieuw.</p>
<h2 id="h2-Web320Project20Trend133025"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h2><p>Deze week daalde de totale marktkapitalisatie van de zeven soorten projecten over de hele linie, en de meeste koersen daalden scherp. De markt werd beïnvloed door de daling van de Amerikaanse aandelen, en de algehele neerwaartse trend was zeer duidelijk. Onlangs werd de algehele markt voornamelijk beïnvloed door externe factoren, en er wordt verwacht dat er een nieuwe ronde van marktfluctuaties zal zijn bij het sluiten van het weekend.</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>-6.8%</td>
<td>SPR,ACG,CUDOS</td>
<td>De totale marktkapitalisatie van de Laag 1 track daalde aanzienlijk en de groei van de top munten bleef boven de 20%. Over het algemeen presteerden de meeste projecten slecht.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>-20.0%</td>
<td>VERTRAGING, EPII, MINT</td>
<td>De sector van Layer 2 zag een grote daling, met een algemene daling over de hele linie, en de winsten van de topmunten waren zeer beperkt.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-11.9%</td>
<td>AX, DEPAY, SQT</td>
<td>De totale marktkapitalisatie van de DeFi-sector is gedaald en de winsten van de topmunten zijn gelijkmatig verdeeld. Over het algemeen is de marktprestatie slecht.</td>
</tr>
<tr>
<td>NFT</td>
<td>-19.5%</td>
<td>MSTR,METADOGE,PONCH</td>
<td>De totale waarde van de NFT-markt daalde scherp. De groei van de topmunten was zeer ongelijk verdeeld, geconcentreerd in een paar individuele munten, terwijl de meeste andere munten voornamelijk daalden.</td>
</tr>
<tr>
<td>MEME</td>
<td>-19.7%</td>
<td>MINDS,METADOGE,GME</td>
<td>De MEME-cointrack daalde scherp, maar de groei van de topstijgende munten is nog steeds acceptabel. De groei is echter geconcentreerd in individuele munten, en de meeste munten zijn voornamelijk in een neerwaartse trend.</td>
</tr>
<tr>
<td>Vloeibare staking</td>
<td>-12.1%</td>
<td>MSTR,LAY3R,LBR</td>
<td>Deze sector zag een zekere daling. Behalve MSTR, lijken andere munten over het algemeen over de hele linie te dalen.</td>
</tr>
<tr>
<td>AI</td>
<td>-19.9%</td>
<td>MINDS,ARCX,SENT</td>
<td>De AI-track daalde scherp, waarbij de winsten van de topmunten geconcentreerd waren in individuele munten. Het algehele traject werd sterk beïnvloed door de daling op de totale markt, wat het algehele traject sterk beïnvloedde.</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 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>