V2VrZWxpamtzIFdlYjMtb25kZXJ6b2Vr772cRGUgbWFya3Qgc3RlZWcgb3ZlciBkZSBoZWxlIGxpbmll

<p><img src="https://gimg2.gateimg.com/image/article/1745564796weeklyweb3research.png" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht130299"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>Deze week, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> heeft een sterke opleving doorgemaakt en is over de hele linie gestegen. Beïnvloed door de verschuiving in het tariefbeleid van Trump en de kwestie van de onafhankelijkheid van de Federal Reserve, heeft de cryptomarkt een nieuwe golf van liquiditeit en kapitaalinstroom verwelkomd en een grootschalige stijging gezien, samen met de Amerikaanse aandelenmarkt. Over het algemeen bevindt de markt zich momenteel in een staat van snelle stijging, en de korte termijn trend van de markt is voornamelijk een voortdurende inhaalslag.</p>
<p>De meeste van de belangrijkste munten op de markt lieten deze week een relatief duidelijke stijgende trend zien. Aangezien de marktsentimentzorgen veroorzaakt door het tariefbeleid van Trump afnemen en de dollar verzwakt vanwege het onafhankelijkheidsprobleem van de Federal Reserve, heeft de cryptomarkt een aanzienlijke stijging gezien.</p>
<p>Over het algemeen werd de markt deze week nog steeds sterk beïnvloed door externe factoren, maar de algehele liquiditeit is aanzienlijk verbeterd, waardoor de markt mogelijk kan ontsnappen aan de vorige aanhoudende consolidatietoestand. De algehele markttrend voor de week toonde een snelle stijging op korte termijn, en brak eens door de $3 biljoen grens in een kort tijdsbestek. Er is een lichte daling en het is zeer waarschijnlijk dat de markt een nieuwe ronde van zweven zal inluiden tegen het einde van de week.</p>
<p>De prijs van BTC is deze week aanzienlijk gestegen. Na een piek boven de $93.000, schommelt de prijs momenteel binnen een kleine marge en blijft rond de $93.500. Het is zeer waarschijnlijk dat het op korte termijn opnieuw een nieuw recordhoogte zal behalen.</p>
<p>De wekelijkse prijsstijging van ETH is groter dan die van BTC. De munt is licht gedaald na het doorbreken van $1.800. Het wekelijkse hoogtepunt lag rond $1.811 en blijft momenteel rond $1.766.</p>
<p>De prijstrend van belangrijke cryptocurrencies is deze week voornamelijk stijgend. De totale marktwaarde van de cryptomarkt is gestegen tot ongeveer $2,93 biljoen, een daling van ongeveer 0,3% in 24 uur. De huidige prijs van BTC is ongeveer $93.500. De huidige prijs van ETH is ongeveer $1.760.</p>
<p>De algehele cryptomarkt steeg deze week aanzienlijk. De meeste mainstream munten stegen in prijs als gevolg van externe factoren, en de algehele gemiddelde stijging was de grootste in de recente tijd. De topmunt met de grootste stijging was TRUMP, die in een week met ongeveer 58% steeg en werd geprijsd op ongeveer $12. De recente snelle stijging van deze munt weerspiegelt ook de voortdurende impact van een reeks beleidsmaatregelen na de ambtsperiode van Trump op de cryptomarkt.</p>
<p>Dit weekend, het algemene <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> wordt verwacht dat er lichte schommelingen zullen optreden, waarbij een opwaartse trend de belangrijkste trend blijft op korte termijn. Echter, de stijging en daling van belangrijke munten worden nog steeds sterk beïnvloed door externe nieuwsfactoren, met name de algemene problemen waarmee de daaropvolgende volwassenheid van Amerikaanse schatkistobligaties wordt geconfronteerd.</p>
<h2 id="h2-Cryptomarkt499672"><a name="Cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptomarkt</h2><p>🔥Volgens Cointelegraph op maandag zei Bloomberg senior commodity strateeg Mike McGlone dat met de implementatie van Trump’s recente beleid, beleggers zijn overgestapt op veiligere activa zoals goud.</p>
<p>🔥Zoals Cointelegraph maandag meldde, waarschuwde het on-chain analyseplatform CryptoQuant in zijn Quicktake-blogpost dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> markt staat op het punt een schok te ervaren.</p>
<p>🔥Volgens Riabiz verwacht Rick Wurster, de pas benoemde CEO van Charles Schwab, om binnen de komende 12 maanden directe spot crypto-handel te lanceren, en spot crypto-handel zal een ‘gok’ worden voor elke grote makelaarsfirma.</p>
<p>🔥Volgens CoinDesk heeft 21Shares een rapport uitgebracht waarin staat dat op basis van een analyse van historische trends en huidige marktsignalen wordt verwacht dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> tegen het einde van 2025 $138.555 zal bereiken.</p>
<p>Volgens Cointelegraph toont Glassnode-data aan dat Bitcoin-walvissen zich nog steeds in een sterke accumulatiezone bevinden. Momenteel absorberen grote houders (walvissen en haaien) die meer dan 100-1.000 Bitcoins vasthouden, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> met de snelste snelheid in de geschiedenis. De huidige absorptie van deze groep heeft de jaarlijkse uitgifte van Bitcoin al met meer dan 300% overtroffen.</p>
<p>🔥Volgens LedgerInsights heeft de Bank for International Settlements (BIS) deze week een paper uitgebracht waarin de financiële stabiliteitsrisico’s van cryptocurrencies en gedecentraliseerde financiën (DeFi) worden onderzocht. De meeste centrale bankfunctionarissen zijn van mening dat cryptocurrencies te klein en zelfstandig zijn, dus ze vormen nog geen financieel stabiliteitsrisico.</p>
<p>🔥Tether CEO Paolo Ardoino zei dat de wereldwijde gebruikers van <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Stablecoin (USDT) heeft de 450 miljoen overschreden en momenteel worden elk kwartaal meer dan 30 miljoen nieuwe gebruikers toegevoegd. De belangrijkste groei komt uit opkomende markten. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> blijft wereldwijd de popularisering van de ‘digitale dollar’ bevorderen.</p>
<p>🔥Adam, een macro-onderzoeker bij Greeks.live, heeft een Chinese gemeenschapsbrief vrijgegeven waarin staat dat het marktsentiment verdeeld was. Sommige handelaren waren optimistisch over de prestaties van altcoins tijdens het weekend en geloofden dat SOL meer dan 10 keer vanaf de bodem was gestegen, maar er waren ook opvattingen die waarschuwden dat dit wellicht de laatste waanzin was.</p>
<p>🔥Volgens Bitcoinist zijn zowel stieren als beren er niet in geslaagd om de situatie volledig onder controle te krijgen na enkele dagen van consolidatie. Deze onbeslistheid weerspiegelt de algemene onzekerheid op de wereldwijde financiële markten.</p>
<p>🔥Michael Saylor, oprichter van Strategie (voorheen MicroStrategy), heeft opnieuw informatie vrijgegeven over Bitcoin Tracker op het X-platform: “Het aantal oranje stippen is niet genoeg.”</p>
<p>🔥CryptoQuant-analist Carmelo Alemán schreef dat op 14 april 2025 de gerealiseerde marktkapitalisatie van Bitcoin (of de gerealiseerde marktwaarde van Bitcoin) een recordhoogte bereikte.</p>
<p>🔥Volgens The Block bereikte BTC vandaag een nieuw hoogtepunt, voor het eerst sinds begin april, gedreven door het herstel van de wereldwijde liquiditeit en institutionele holdings. Strategy verhoogde zijn holdings met 3.459 BTC aan het begin van deze maand, en de groei van de totale M2-geldhoeveelheid dreef ook de markt omhoog. Analisten waarschuwden echter dat het nog te vroeg is om te praten over een bullmarkt omdat het Amerikaanse tariefbeleid nog steeds onduidelijk is.</p>
<p>🔥Volgens de Wall Street Journal overweegt een bankenconsortium, met inbegrip van Duitsland’s Deutsche Bank en de Britse Standard Chartered Bank, naar verluidt zijn crypto-activiteiten uit te breiden naar de Verenigde Staten, aldus bronnen.</p>
<p>🔥Pavel Durov, oprichter van Telegram, plaatste op het officiële TG-kanaal dat Frankrijk bijna vorige maand crypto heeft verboden. De Senaat heeft een wet aangenomen waarbij communicatieapplicaties een achterdeur moeten opzetten voor de politie om toegang te krijgen tot privé-informatie. Gelukkig werd de wet afgewezen door de Nationale Vergadering. Echter, drie dagen geleden sprak de politiechef van Parijs opnieuw zijn steun uit voor de wet.</p>
<p>🔥Crypto-analist PlanB plaatste op het X-platform dat hij gelooft dat <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, als een ‘gecentraliseerd, voorgeproduceerd, op PoS gebaseerd en willekeurig veranderlijk aanbodmechanisme’ project, is schadelijk voor de cryptowereld, en stelde botweg dat het ‘alle spot verdient’.</p>
<p>🔥Volgens een grafiek gedeeld door Bloomberg ETF-analist Eric Balchunas, zijn er momenteel 72 crypto-asset ETF’s die verschillende thema’s bestrijken zoals <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a>, <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> en zelfs ‘2x Melania’ geregistreerd bij de U.S. SEC, in afwachting van goedkeuring of noteringsmogelijkheden.</p>
<p>🔥Julio Moreno, directeur onderzoek bij CryptoQuant, zei op het X-platform dat het weerstandsniveau van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> kan rond de $91.000 tot $92.000 liggen, wat overeenkomt met de prijs die door handelaren op de keten gerealiseerd wordt.</p>
<p>🔥Jeff Kendrick, een analist bij Standard Chartered Bank, zei dat Bitcoin naar een all-time high zou kunnen stijgen als zorgen over de onafhankelijkheid van de Federal Reserve aanhouden. Hij zei dat vanwege zijn gedecentraliseerde grootboek, de cryptocurrency een hedge is tegen risico’s in het bestaande financiële . Dit komt tot uiting in het risico van Amerikaanse schatkistpapieren nadat Trump hintte dat hij Federal Reserve-voorzitter Powell zou kunnen verwijderen vanwege zijn hoop op verlaging van de rentevoeten.</p>
<p>🔥Bernstein is van mening dat hoewel de korte termijn volatiliteit blijft bestaan, het vooruitzicht voor digitale activa optimistisch blijft en wijst op vijf belangrijke structurele katalysatoren die de veerkracht van Bitcoin en het toekomstige opwaartse potentieel ondersteunen.</p>
<p>🔥Volgens CoinDesk staat de huidige BTC/Nasdaq-verhouding op 4,96, dicht bij zijn all-time high. Eerder bereikte de verhouding een record van 5,08 in januari 2025, toen Bitcoin een recordhoogte bereikte.</p>
<p>🔥Volgens de laatste gegevens van 8marketcap heeft Bitcoin zilver en technologiereus Amazon overtroffen en is het gestegen naar de zesde plaats in de wereldwijde activawaarde.</p>
<p>🔥Volgens Bloomberg heeft de zoon van Trump een nieuw bedrijf opgericht, American Bitcoin, samen met andere investeerders, en het samengevoegd met het publiekelijk genoteerde mijnbouwbedrijf Hut 8 Corp., dat wordt geleid door CEO Asher Genoot en Chief Strategy Officer Michael Ho.</p>
<p>🔥Volgens Globenewswire heeft Trump Media Technology Group (DJT.O) een bindende overeenkomst getekend met cryptohandelplatform Crypto.com en vermogensbeheermaatschappij Yorkville America Digital om een reeks ETF’s te lanceren via het merk Truth.Fi.</p>
<p>🔥Volgens de FT hebben drie ingewijden onthuld dat Cantor Fitzgerald, geleid door Brandon Lutnick, zoon van de Amerikaanse minister van Handel Howard Lutnick, samenwerkt met SoftBank, <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> en Bitfinex om een ​​Bitcoin-acquisitieplatform van meerdere miljarden dollars te bouwen.</p>
<p>🔥 Volgens Cointelegraph, <a href="/price/chiliz-chz" rel="nofollow noopener noreferrer" target="_blank">Chiliz</a>, een dochteronderneming van SportsFi, heeft gesproken met de Amerikaanse SEC om te discussiëren over investeringen en herintreding op de Amerikaanse cryptomarkt onder leiding van het crypto-vriendelijke Witte Huis, evenals het bevorderen van regelgevende transparantie voor digitale activa.</p>
<p>🔥Volgens CoinDesk hebben ingewijden onthuld dat de Nederlandse bank ING een stablecoin aan het ontwikkelen is, in de hoop te profiteren van de nieuwe Europese crypto regelgeving die vorig jaar van kracht werd.</p>
<p>🔥De officiële website van de meme coin “TRUMP” van de Amerikaanse president Trump heeft woensdag lokale tijd aangekondigd dat het de top 220 houders van de munt zal uitnodigen voor een diner in een golfclub in de buurt van Washington op 22 mei, waarbij wordt beweerd dat er een mogelijkheid zal zijn om “first-hand” informatie van Trump te horen over de toekomst van cryptocurrency.</p>
<p>CoinGecko meldde donderdag dat de totale marktwaarde van cryptocurrencies voor het eerst sinds 7 maart 2025 de $3 biljoen heeft overschreden.</p>
<p>🔥Volgens Cointelegraph is Bitcoin deze week sterk gestegen en hebben gerelateerde exchange-traded funds (ETF’s) een sterke instroom gekend. Analisten geloven dat Bitcoin binnenkort $100.000 zou kunnen bereiken, maar Markus Thielen, hoofd onderzoek bij 10xResearch, zei in een marktrapport: ‘Aangezien indicatoren voor het aanmaken van stablecoins nog niet terug zijn op actieve niveaus, blijven we voorzichtig over de duurzaamheid van de huidige Bitcoin-rally’.</p>
<p>🔥Volgens SolanaFloor heeft SOL Strategies, een Canadees beursgenoteerd bedrijf, converteerbare obligatiefinanciering tot $500 miljoen verkregen van ATW Partners, de grootste financiering in zijn soort in de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>-ecosysteem.</p>
<p>🔥Volgens Cointelegraph heeft het Amerikaanse Bureau van de Controller van de Munteenheid (OCC) zijn standpunt ingenomen over cryptocurrencies en banken, waarbij wordt gezegd: “OCC heeft verduidelijkt dat bepaalde crypto-gerelateerde activiteiten wettelijk zijn toegestaan.”</p>
<p>🔥Volgens CoinDesk toont het nieuwste ‘2025 Travel Rule Compliance Report’ van Notabene aan dat 90% van de 91 ondervraagde virtuele activadienstverleners naar verwachting volledig zal voldoen aan de antiwitwasreisregels tegen medio 2025, en alle ondervraagde instellingen hebben beloofd om tegen het einde van het jaar aan de normen te voldoen.</p>
<p>🔥Volgens Crypto America vragen ongeveer 15 cryptocurrency- en fintechbedrijven bankvergunningen aan bij het Amerikaanse Bureau van de Controller van de Munteenheid (OCC), en sommigen van hen zoeken een handigere manier om federale hoofdaccounts te verkrijgen.</p>
<p>🔥On-chain analysebedrijf Glassnode publiceerde een analyse over het X platform, waarin staat dat de Bitcoin voorraadkaart laat zien dat verkopers die voor het eerst in april Bitcoin kochten, sterke activiteit vertoonden. Ondanks dat de prijzen stegen, bleef het ‘fear of missing out’ (FOMO) sentiment op de markt toenemen en stroomden er nieuwe fondsen binnen.</p>
<p>🔥CoinShares-onderzoeksdirecteur James Butterfill schreef op het X-platform dat sinds de aankondiging van de VS ‘Bevrijdingsdag’ tarief op 2 februari, Bitcoin de Nasdaq 100-index met 15,9% heeft overtroffen, waarbij de voordelen als gedecentraliseerde investeringsactiva worden benadrukt.</p>
<h2 id="h2-Regelgeving20amp20Macrobeleid649307"><a name="Regelgeving &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgeving &amp; Macrobeleid</h2><p>Volgens Cointelegraph is in Arizona een cryptoreserve-wetsvoorstel aangenomen door het Huis van Afgevaardigden en is het nu slechts één succesvolle stemming verwijderd van indiening bij het bureau van de gouverneur ter formele goedkeuring. Op 17 april werd de Strategic Digital Asset Reserve Act van Arizona (SB 1373) goedgekeurd door de volledige commissie van het Huis. Voordat het wetsvoorstel voor de derde en laatste keer wordt voorgelezen en ter stemming wordt gebracht, moet het worden beoordeeld door 60 leden van het Huis van Afgevaardigden. SB 1373 heeft tot doel een strategisch reservefonds voor digitale activa op te richten, dat zal bestaan uit digitale activa die in beslag zijn genomen bij strafrechtelijke vervolging en zal worden beheerd door de penningmeester van de staat.</p>
<p>De officiële website van het Hooggerechtshof van het Volk heeft onlangs een theoretisch onderzoeksartikel gepubliceerd getiteld “Verbetering van het identificatie- en bewijsmechanisme van virtuele valuta betrokken bij strafzaken”. In het artikel staat dat vanwege de anonimiteit en technische complexiteit van virtuele valuta, het moeilijk is om het te identificeren in strafzaken, moeilijk om het op te sporen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> van fondsen, en moeilijk om de waarde ervan te bepalen.</p>
<p>🔥De People’s Bank of China, de State Administration of Financial Supervision, de State Administration of Foreign Exchange en de Shanghai Municipal People’s Government hebben gezamenlijk het “Shanghai International Financial Center Actieplan uitgegeven om de gemak van grensoverschrijdende financiële diensten verder te verbeteren.”</p>
<p>🔥Democratische afgevaardigde Nydia Velazquez uit New York heeft de Puerto Rico Digital Asset Fair Taxation Act geïntroduceerd, die tot doel heeft te voorkomen dat investeerders het Amerikaanse grondgebied van Puerto Rico gebruiken als een belastingparadijs voor crypto’s.</p>
<p>🔥Volgens Cointelegraph heeft de Europese Centrale Bank (ECB) gewaarschuwd voor de mogelijke gevolgen van de radicale steun van de Verenigde Staten voor de crypto-industrie, waarbij wordt gezegd dat de toename van Amerikaanse dollar-stablecoins de stabiliteit van de Europese financiële . Volgens een beleidsdocument dat door POLITICO is verkregen, heeft de ECB opgeroepen tot een herziening van het regelgevingskader voor de Crypto Asset Market Regulation (MiCA) slechts enkele maanden nadat het van kracht was geworden. In de kern van het geschil staat dat Amerikaanse hervormingen gesteund door president Trump de Europese markten kunnen overspoelen met op de dollar luidende stablecoins. De ECB is bezorgd dat hierdoor Europees kapitaal naar Amerikaanse activa zou kunnen stromen, de financiële soevereiniteit van de EU zou kunnen verzwakken en banken bloot zou kunnen stellen aan liquiditeitsrisico’s.</p>
<p>🔥Volgens Watcher.Guru zei Michael Saylor: ‘Paul Atkins, voorzitter van de U.S. Securities and Exchange Commission, zal een positieve houding hebben ten opzichte van Bitcoin.’ Eerder kwam het nieuws dat Paul Atkins werd beëdigd als opvolger van Gary Gensler als voorzitter van de U.S. SEC.</p>
<p>🔥Volgens Bloomberg ondertekende Trump begin maart een uitvoeringsbevel waarin werd opgeroepen tot de oprichting van een apart strategisch reservefonds van Bitcoin en andere tokens, en waarin de Minister van Financiën werd gevraagd om de juridische en investeringsoverwegingen van het plan binnen 60 dagen te ueren.</p>
<p>🔥Volgens CNBC nam Mark Uyeda, commissaris van de U.S. Securities and Exchange Commission (SEC), deel aan het programma ‘Money Movers’ om te bespreken hoe de huidige SEC verschilt van de SEC van Gary Gensler en wanneer het cryptoreguleringskader kan worden verwacht. Uyeda zei dat de cryptowerkgroep hard werkt om een regelgevend kader te ontwikkelen.</p>
<p>🔥Volgens officieel nieuws van de U.S. Securities and Exchange Commission (SEC) zal SEC-voorzitter Paul Atkins een toespraak houden tijdens de volgende crypto-ronde tafel op 25 april. Eerder werd gemeld dat de U.S. SEC op 25 april de derde crypto-beleidsronde tafel zal houden, met de focus op bewaarproblemen.</p>
<p>🔥Volgens Interfax zullen het Russische Ministerie van Financiën en de Centrale Bank een crypto-beurs opzetten voor high-net-worth investeerders als een van de nalevingsmechanismen onder het ‘experimentele wettelijke’. Deelnemers moeten activa hebben van meer dan 120 miljoen roebel of een jaarinkomen van meer dan 50 miljoen roebel. Het plan heeft tot doel om cryptotransacties te legaliseren en de markttransparantie te vergroten, maar het is beperkt tot buitenlandse handelsafrekeningen en is niet van toepassing op binnenlandse betalingen. De relevante transacties zullen op proefbasis worden gelanceerd over 6 maanden.</p>
<h2 id="h2-Crypto20Markt20Hoogtepunten652235"><a name="Crypto Markt Hoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Hoogtepunten</h2><p>⭐️Afgelopen week heeft de cryptomarkt als geheel een grootschalige stijging gezien. Beïnvloed door de vermindering van zorgen over het tariefbeleid van Trump en de kwestie van de onafhankelijkheid van de Federal Reserve, hebben de Amerikaanse aandelenmarkt en de cryptomarkt een aanzienlijk herstel gezien, en de cryptomarkt heeft over de hele linie een algemene stijging gezien. De afgelopen week hebben voornamelijk mainstream coins korte-termijn snelle dagelijkse stijgingen gezien. De huidige markt zit in een kleine op- en neergaande trend, en de huidige markt wordt verwacht een compenserende stijging te behouden.</p>
<p>⭐️Deze week stond de stijging van de prijs van TRUMP op de cryptomarkt op de eerste plaats onder de mainstream munten, met een stijging van ongeveer 60%. Dit komt voornamelijk omdat de munt de officiële door Trump gecertificeerde token is. Onlangs is de prijs door Trump-gerelateerde dynamiek kortstondig snel gestegen. De prijs van TRUMP is weer gedaald en blijft rond de $12. Het wekelijkse hoogtepunt ligt rond de $14,6. Momenteel bevindt het zich in een kortetermijnfluctuatietrend en de prijs is relatief stabiel.<br><img src="https://gimg2.gateimg.com/image/article/17455650021.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties218864"><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-Bitcoin20BTC53441"><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/17455650262.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> De trend is continu gestegen sinds de opening en de prijs brak een keer door $94,000 heen. Het is iets gedaald, maar het blijft nog steeds in het recente hoogste prijsbereik. Beïnvloed door externe nieuwsfactoren bereikte de BTC-prijs een recordhoogte en heeft de totale kapitaalschaal de zesde grootste activa ter wereld bereikt. De BTC-prijs zal waarschijnlijk op korte termijn blijven stijgen en de continue stijging en daling in een klein bereik zal de mainstreammarkt zijn.</p>
<h3 id="h3-Ethereum20ETH229244"><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/17455650523.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>De prijstrend van ETH deze week is hoger dan die van BTC, maar de korte termijn ups en downs zijn ook volatieler. De prijs van ETH piekte boven de $ 1.800 in een week. Momenteel ligt de prijs van ETH rond de $ 1.760. De daaropvolgende trend zal waarschijnlijk blijven stijgen en dalen in een klein bereik, maar er is een grote opwaartse ruimte. Er wordt verwacht dat er bepaalde prijswijzigingen zullen zijn tijdens het weekend.</p>
<h2 id="h2-Web320Project20Trend614599"><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 is deze week over de hele linie gestegen en de stijging bereikte een recent hoogtepunt. De markt maakte een opwaartse herstel door als gevolg van externe factoren. Daarom werden de meeste tracks gedomineerd door herstel. Verwacht wordt dat de huidige belangrijkste trend zal aanhouden tijdens de weekendafsluiting en een lichte stijgende trend de meest waarschijnlijke trend zal zijn.</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>11.5%</td>
<td>PAC,MIRAI,KRU</td>
<td>De totale marktkapitalisatie van de Layer 1 track nam aanzienlijk toe, en de stijging van de topmunten bleef binnen een gematigd bereik, met over het algemeen een relatief gelijkmatige verdeling.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>24.2%</td>
<td>BB,RENTA,MERL</td>
<td>De sector van laag 2 herstelde aanzienlijk, maar de algehele gemiddelde stijging was gelijkmatig verdeeld, en de stijging van de topmunten was matig en niet groot.</td>
</tr>
<tr>
<td>DeFi</td>
<td>15.1%</td>
<td>PBTC,COMBO,FLURRY</td>
<td>De totale marktkapitalisatie van de DeFi-sector is aanzienlijk hersteld, maar de winsten van de topmunten zijn geconcentreerd in individuele munten, wat een trend is die in vergelijking met vorige week is voortgezet.</td>
</tr>
<tr>
<td>NFT</td>
<td>24.6%</td>
<td>DROMEN, CHMPZ, YAKA</td>
<td>De totale marktkapitalisatie van de NFT-markt is sterk hersteld, maar de topstijgende munten zijn nog steeds voornamelijk uitgebreide projecten, en de algehele groeiverdeling is relatief gelijkmatig.</td>
</tr>
<tr>
<td>MEME</td>
<td>21.3%</td>
<td>CATX,CATME,UNI</td>
<td>De MEME coin track heeft een aanzienlijke stijging doorgemaakt, maar deze groei is geconcentreerd in de topindividuele munten, met grote verschillen binnen de track.</td>
</tr>
<tr>
<td>Vloeibaar Staken</td>
<td>12.6%</td>
<td>QCKUJI,BRG,RAPR</td>
<td>Deze sector vertoonde een zekere mate van stijging, maar de winsten van de topmunten zijn relatief geconcentreerd, en de winsten zijn eigenlijk vrij beperkt in vergelijking met andere tracks.</td>
</tr>
<tr>
<td>AI</td>
<td>21.8%</td>
<td>MINDS,SUIDEPIN,SENT</td>
<td>De AI-track maakte een aanzienlijk herstel door, maar de winsten in de topmunten zijn geconcentreerd in individuele munten, terwijl de winsten in andere munten op het algehele spoor relatief klein zijn.</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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>