V2VrZWxpamtzIFdlYjMtb25kZXJ6b2Vr772cQWxnZWhlbGUgbWFya3QgZmx1Y3R1ZWVyZGUgbmVlcndhYXJ0cw==

<p><img src="https://gimg2.gateimg.com/image/article/1741917881weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht912883"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>De macro-economie en de top van het Witte Huis hadden invloed op het geheel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>, die deze week hoog opende en laag eindigde, met een relatief duidelijke neerwaartse trend. De externe nieuwsfactoren waren gecompliceerd, wat het positieve effect van Trump’s aankondiging van de cryptowarreserve van vorige week verwaterde en nadelige effecten met zich meebracht voor de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>, vooral de altcoins. Hoewel de algehele markt de laatste tijd grotendeels in een neerwaartse spiraal zit, is de prestatie van mainstream munten nog steeds relatief veerkrachtig en is er geen grootschalige daling geweest zoals bij altcoins.</p>
<p>Over het algemeen was de markttrend voornamelijk volatiel en neerwaarts gedurende het grootste deel van de week, en de totale marktwaarde daalde ook. Het marktsentiment bleef ongeveer een week op ongeveer 20. Bijna aan het einde van de week bleven de meeste topmainstreammunten een aanhoudende kleine daling handhaven, en er is geen teken van herstel op de totale markt.</p>
<p>De meeste belangrijke cryptocurrencies vertoonden deze week een neerwaartse trend, voornamelijk met korte termijn aanhoudende dalingen. De mogelijkheid van marktherstel op korte termijn is momenteel laag en wordt zwaar beïnvloed door de macro-economie. Tegelijkertijd zijn veranderingen in externe beleidsfactoren kritischer voor marktveranderingen.</p>
<p>Deze week is de prijs van BTC aanzienlijk gedaald en bevindt zich nu weer in het bereik van $80.600. Er is nog steeds een risico op verdere daling. Als het onder de belangrijke prijs van $75.000 daalt, bestaat de kans op een compenserende daling, wat zal leiden tot grootschalige liquidatie. Het dieptepunt van BTC ligt rond $76.000 en het hoogtepunt rond $84.000.</p>
<p>ETH’s prijstrend is vergelijkbaar met BTC, met een relatief grotere daling. Het hoogtepunt van de week was rond $2.142, en het dieptepunt was rond $1.792. De prijstrends van belangrijke mainstream munten hebben grotendeels een voortdurende neerwaartse trend laten zien, en de trage markt is geïntensiveerd. De algehele marktwaarde van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> is aanzienlijk gedaald, en heeft het niveau van ongeveer $2,63 biljoen bereikt, een daling van 1,53% in 24 uur.</p>
<p>De algehele daling op de cryptomarkt van deze week is vergeleken met vorige week versterkt, en het neerslachtige sentiment is ernstiger geworden door het nieuws. De huidige prijs van BTC ligt rond de $80.500, en de huidige prijs van ETH blijft rond de $1.800.</p>
<p>De cryptomarkt bevindt zich deze week in een neerwaartse trend en mainstream munten ontbreken effectieve opwaartse signalen. De topmunt met de grootste stijging is TIA, maar de daadwerkelijke stijging is nog steeds beperkt en bedraagt ongeveer 8,13% in een week, wat praktische referentiebetekenis mist.</p>
<p>De cryptomarkt wordt verwacht dit weekend kleine schommelingen te ondergaan, met een grote kans op verdere daling.</p>
<h2 id="h2-Crypto20Markt216615"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥Volgens gegevens van Alternative.me daalde de crypto-paniek- en hebzuchtindex op maandag naar 20, veranderde van paniek naar extreme paniek, en dit sentiment bleef aanhouden tot het einde van de week.</p>
<p>🔥The U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF-markt heeft vier opeenvolgende weken uitstroom gezien. Volgens Farside Investors omvatten de grootste wekelijkse uitstroom van ETF’s in de week eindigend op 7 maart: Fidelity Smart Origin <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Fonds (FBTC) had een nettouitstroom van $201 miljoen, wat zes opeenvolgende weken van uitstroom was.</p>
<p>🔥Volgens Cointelegraph, Iliya Kalchev, analist bij Dispatch op het digitale activa-investeringsplatform <a href="/price/nexo-nexo" rel="nofollow noopener noreferrer" target="_blank">Nexo</a>, zei dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> prijzen zullen onder druk blijven staan door macro-economische ontwikkelingen en mondiale handelskwesties. Volgende week zullen alle ogen gericht zijn op belangrijke economische gebeurtenissen in de Verenigde Staten, waaronder de Consumentenprijsindex, die naar verwachting een vertraging van de inflatie zal markeren. Het rapport over openstaande vacatures zal een belangrijke indicator zijn van de kracht van de arbeidsmarkt en het potentieel voor lagere rentetarieven.</p>
<p>🔥De CEO van First Digital zei dat de prioritering van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> door de Verenigde Staten als een reserve-activum zijn status als digitaal goud consolideert en een precedent schept voor het versnellen van de ontwikkeling van regelgevende kaders en het bevorderen van institutionele adoptie wereldwijd.</p>
<p>🔥On-chain data toont aan dat de Salvadoraanse regering op 10 maart haar bezittingen heeft verhoogd met 5 BTC ($415.000), en haar totale bezittingen nu 6.111 BTC bedragen, ter waarde van $492,5 miljoen.</p>
<p>🔥Julio Moreno, hoofd onderzoek bij CryptoQuant, schreef op het X-platform over waarom de prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is gedaald. Simpel gezegd, de groei van de vraag naar Bitcoin op spotmarkten neemt af, terwijl de shortposities van Bitcoin de futuresmarkt domineren.</p>
<p>🔥Volgens Cointelegraph heeft het crypto-project WLFI van de Trump-familie eerder aangekondigd een partnerschap aan te gaan met Sui Network en van plan te zijn SUI-tokens op te nemen in zijn strategische tokenreserve “Macro Strategy.”</p>
<p>🔥Volgens Crypto.news blijkt uit de gegevens van CryptoSlam dat de transactievolume van NFT’s deze week is gestegen naar $121.5 miljoen, een stijging van 15.27% ten opzichte van de vorige week.</p>
<p>🔥Volgens News.Bitcoin steeg de totale marktwaarde van stablecoins in februari met $7,7 miljard, wat de stijgende vraag naar “digitale dollars” op de cryptomarkt benadrukt. De belangrijkste situatie van de stablecoin-markt in februari was: De marktwaarde van USDS steeg met 64%; De marktwaarde van PYUSD steeg met 49%; De marktwaarde van USDT bedroeg ongeveer $ 143 miljard (een stijging van $ 2,5 miljard alleen al in februari); De marktwaarde van USDC steeg met 7%.</p>
<p>🔥Volgens DL News zei Matt Hougan, Chief Investment Officer van Bitwise, in een investeringsmemo deze week dat Trump de spelregels in de cryptomarkt heeft veranderd. Het opzetten van een strategische cryptoreserve in de Verenigde Staten zal een domino-effect veroorzaken en gezien worden als het eerste schot in een Bitcoin-wapenwedloop. Honduras, Mexico of Guatemala letten op de Bitcoin-strategieën van de Verenigde Staten en El Salvador. Alle landen kunnen Bitcoin bevorderen tot een belangrijke mondiale monetaire activa.</p>
<p>🔥eGirl Capital partner Degen Spartan deelde zijn visie op sociale media, waarbij hij verwees naar de classificatie van beleggingsexpert Charles D. Ellis, die modern beleggen beschouwt als een ‘verliezersspel’, waarbij overwinning afhangt van het maken van minder fouten.</p>
<p>🔥DeFi-analist Adaora Favour Nwankwo schreef op het X-platform: De prijstrend van Bitcoin is nauw verbonden met Amerikaanse economische indicatoren. Het volgende is een mogelijke scenario: Als er een recessie optreedt, is de maximale potentiële daling van Bitcoin ongeveer $50.000; als er geen recessie is, wordt verwacht dat de bodemprijs tussen $70.000 en $75.000 zal liggen.</p>
<p>🔥Volgens Walter Bloomberg zei Deutsche Bank-analist Marion Laboure dat de cryptovolatiliteit mogelijk hoog blijft in afwezigheid van duidelijke details over het Bitcoin-reserveplan van Trump.</p>
<p>🔥Michael Saylor, oprichter van Strategy, stelde voor dat de Amerikaanse overheid tegen 2035 25% van de totale voorraad Bitcoin zou moeten verwerven om een strategische reserve van Bitcoin op te bouwen.<br>BTC Inc. CEO David Bailey, een van de tientallen insiders die waren uitgenodigd voor de recente crypto-top van Trump, suggereerde op sociale media dat de twee ideeën van de president gecombineerd zouden kunnen worden om de cryptoreserves te verhogen zonder een cent uit te geven.</p>
<p>🔥De analist wees erop dat de Fed nu te maken heeft met een moeilijke beleidsomgeving. Hoewel een zwakkere banengroei de argumenten voor renteverlagingen ondersteunt, kunnen aanhoudende inflatiezorgen - vooral die welke voortvloeien uit beperkingen aan de aanbodzijde en geopolitieke onzekerheden - de Fed ertoe aanzetten voorzichtig te handelen, en de onzekere omgeving kan de crypto-industrie onder druk zetten.</p>
<p>🔥Crypto-prijzen bleven maandag dalen, doordat escalerende tariefoorlogsspanningen en verzwakkende verwachtingen van verdere renteverlagingen door de Federal Reserve het positieve effect van een reeks pro-crypto-uitspraken van de Amerikaanse president Donald Trump vorige week tenietdeden, meldde Bloomberg.</p>
<p>🔥Volgens Decrypt suggereerde Geoff Kendrick, wereldwijd hoofd van digitaal vermogensonderzoek bij Standard Chartered, dat de Amerikaanse overheid Bitcoin op verschillende budgetneutrale manieren zou kunnen aankopen bij de uitvoering van het recentste uitvoerend bevel van president Trump.</p>
<p>CoinDesk-analist James Van Straten schreef dat sinds president Trump op 20 januari aantrad, de prijs van Bitcoin is gedaald van $109.000 naar $80.000, wat een typisch ‘verkoop op het nieuws’-evenement is geworden. Deze terugval heeft zich voortgezet sinds de Digital Asset Summit op vrijdag. Hoewel de prijstrend kortetermijn-bearishheid kan aangeven, kunnen Bitcoin-stieren het zien als een langetermijn positieve katalysator omdat de Amerikaanse overheid is overgestapt van de vijandige houding van de vorige regering naar een meer vriendelijke houding.</p>
<p>🔥Volgens The Block, de totale transactiekosten gegenereerd door de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk afgelopen week waren slechts 53.800 SOL, het laagste niveau sinds september 2024 en een daling van 10% ten opzichte van de vorige week.</p>
<p>🔥Singapore Exchange Ltd. is van plan om Bitcoin eeuwigdurende futures te lanceren, meldde Bloomberg, een stap van traditionele beurzen om dieper in de cryptoderivatenmarkt te duiken.</p>
<p>Geoff Kendrick, hoofd van het onderzoek naar digitale activa bij Standard Chartered Bank, zei dat de recente prijsschommelingen van Bitcoin consistent zijn met de prestaties van risicovolle activa zoals de ‘Big Seven U.S. Stocks’ in plaats van een probleem met de crypto zelf.</p>
<p>🔥10X Research analist Markus Thielen zei: Nu is niet het moment om te kopen op dips omdat BTC mogelijk zal dalen naar het bereik van $73.000.</p>
<p>🔥Volgens Nate Geraci, president van The ETF Store, heeft Franklin Templeton, dat meer dan $1.5 biljoen aan activa beheert, zich officieel aangesloten bij de <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF competitie.</p>
<p>🔥Volgens ckpool ontwikkelaar Dr-ck heeft een miner met succes Bitcoin blok 887212 gemijnd op solo.ckpool.org met behulp van een 480GH Bitaxe miner met slechts 3.3TH hashrate.</p>
<p>🔥Volgens The Block heeft StarkWare aangekondigd dat het een “strategische Bitcoin-reserve” heeft opgericht en een toenemend bedrag aan fondsen in zijn schatkist zal aanhouden in de vorm van BTC.</p>
<p>🔥Volgens The Block zei Pierre Gramegna, President van het Europees Stabiliteitsmechanisme (ESM), tijdens een persconferentie na de Eurogroepvergadering op maandag dat de steun van de Amerikaanse regering onder leiding van president Trump voor cryptocurrencies de monetaire autonomie van Europa zou kunnen ondermijnen.</p>
<p>🔥 Clearstream, de post-trade tak van Deutsche Börse, heeft aangekondigd dat het later dit jaar cryptobetaling en bewaaroplossingen zal bieden aan institutionele klanten.</p>
<p>🔥Arthur Hayes tweette dat Bitcoin (BTC) een wereldwijde 24⁄7markt, met onbeperkte transacties, kan niet in overmaat worden uitgegeven, falen betekent faillissement of liquidatie, en de financiën van geen enkel land zijn afhankelijk van de stijging van BTC.</p>
<p>🔥Volgens Decrypt hebben de autoriteiten in Californië hun optreden tegen cryptozwendel opgevoerd, waarbij 26 frauduleuze cryptowebsites zijn gesloten en consumenten hebben onthuld dat ze in 2024 meer dan $4,6 miljoen hebben verloren.</p>
<p>Volgens CoinDesk heeft de recente neergang op de cryptomarkt ervoor gezorgd dat de eens zo populaire $120.000 Bitcoin-optie-inzet zijn kroon heeft verloren en is vervangen door een $100.000 call-optie, wat aangeeft dat handelaren hun optimistische verwachtingen heroverwegen.</p>
<p>🔥Zoals Cointelegraph meldde, hebben de nieuwste tegenmaatregelen van de EU de macro-economische onzekerheid vergroot, waardoor cryptografische analisten voorspellen dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> de volatiliteit zal toenemen en kan onder het belangrijke $75.000 ondersteuningsniveau dalen.</p>
<p>🔥Volgens The Block bereikten termen die verband houden met blockchain in documenten van de U.S. Securities and Exchange Commission (SEC) in februari een recordhoogte, waarbij de EDGAR-database meer dan 5.000 gerelateerde vermeldingen registreerde, wat een voortdurende stijgende trend laat zien sinds halverwege 2023.</p>
<p>🔥 Volgens Decrypt ontdekte het Socket Research Team in een nieuwe aanval dat de Noord-Koreaanse hackersgroep Lazarus gelinkt was aan zes nieuwe kwaadaardige npm-pakketten die probeerden backdoors te implementeren om gebruikersreferenties te stelen.</p>
<p>Stark Bank SA, een Braziliaanse online-only bank gesteund door Bezos Expeditions, positioneert zichzelf als de voorkeursbankdienstverlener voor de crypto-startups van het land, inzetten dat dit gebied, dat is uitgesloten door traditionele geldschieters, groei zal stimuleren, volgens Bloomberg.</p>
<p>🔥Massachusetts Representative Kate Lipper-Garabedian heeft een wetsvoorstel ingediend waarin de oprichting van een speciale commissie met leden van de staatswetgevende macht wordt voorgesteld om blockchain- en crypto-gerelateerde zaken te onderzoeken.</p>
<p>🔥Hyperliquid geplaatst op het X-platform: Met betrekking tot de opmerkingen en vragen over de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> lange positie van gebruiker 0xf3f4, hierbij verduidelijken we: er was geen exploitatie van protocolkwetsbaarheid of hacker aanval. De gebruiker had ongerealiseerde winst en verlies (PNL), en trok vervolgens contant geld terug, waardoor zijn marge daalde en zijn positie uiteindelijk gedwongen werd gesloten.</p>
<p>🔥Fox Business News verslaggever Eleanor Terrett plaatste op het X-platform dat twee betrouwbare bronnen onthulden dat de rechtszaak tussen de U.S. Securities and Exchange Commission (SEC) en Ripple bijna ten einde loopt en binnenkort kan eindigen.</p>
<p>🔥Volgens Cryptonews heeft de Autoriteit Financiële Markten (AFM) online crypto- en aandelenhandelsplatform BUX een boete opgelegd van 1,6 miljoen euro voor het overtreden van de sectorregels door nieuwe klanten aan te trekken via financiële influencers en verwijzingsprogramma’s.</p>
<p>🔥Volgens de officiële website is 99,2% van de extra 5% aandelen (5 miljard tokens) van Trump’s crypto-project WLFI verkocht. Volgens eerdere berichten is de prijs van de extra 5% aanbod van Trump’s crypto-project WLFI gestegen tot $0,05, terwijl de vorige ronde prijs slechts $0,015 was.</p>
<p>🔥Santiment plaatste op het X-platform dat het totale handelsvolume van de cryptomarkt is blijven dalen sinds het piekhandelsvolume op 27 februari (toen handelaren optimistisch kochten op dips). Na verdere dalingen in de afgelopen twee weken, vertoonde het gedrag van handelaren vermoeidheid, wanhoop en capitulatie. Wanneer het handelsvolume van grote cryptocurrencies blijft dalen, zelfs tijdens een klein prijsherstel, betekent dit meestal dat het enthousiasme van handelaren is verzwakt.</p>
<h2 id="h2-Regelgeving20amp20Macrobeleid151818"><a name="Regelgeving &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgeving &amp; Macrobeleid</h2><p>🔥De langverwachte White House Crypto Summit is afgerond, maar de resultaten hebben crypto handelaren teleurgesteld en hebben de hete markt die door de markt werd verwacht niet weten te triggeren. In vergelijking met Bitcoin, altcoins zoals Ripple, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> en SOL zijn scherp gedaald. De resultaten van de top waren relatief teleurstellend, met alleen een toezegging om tegen augustus een wettelijk kader voor stablecoins te ontwikkelen en verzekeringen van meer soepele regelgevende maatregelen. Deze maatregelen slaagden er niet in om de marktsentiment zoals verwacht aan te wakkeren.</p>
<p>🔥Volgens Cointelegraph heeft de Senaat van Utah de HB230 “Blockchain and Digital Innovation Amendment”-wet aangenomen, maar de clausule geschrapt die de staatskas oorspronkelijk toestond om in Bitcoin te investeren. Het wetsvoorstel werd aangenomen met een stemming van 19-7-3 en zal worden voorgelegd aan gouverneur Spencer Cox om te worden ondertekend.</p>
<p>🔥De Amerikaanse president Trump heeft een uitvoerend bevel ondertekend om een strategische Bitcoin-reserve en een afzonderlijke digitale activareserve op te richten. In dit verband is Zach Pandl, hoofd onderzoek bij Grayscale Investments, van mening dat Bitcoin dit jaar niet de strategische reserves van de Verenigde Staten nodig heeft om verder te waarderen. Hij verwacht dat naarmate het adoptiepercentage toeneemt, de prijs van Bitcoin zal stijgen. Tegelijkertijd zal Bitcoin dit jaar beginnen een rol te spelen als een middel om waarde op te slaan, vooral te midden van zorgen dat het tariefbeleid van Trump de inflatie opnieuw kan doen stijgen.</p>
<p>🔥Volgens Bitcoin.com wacht het SB 21-wetsvoorstel, dat eerder door de Senaat van Texas is aangenomen, momenteel op goedkeuring door het Huis van Afgevaardigden. Het SB 21-wetsvoorstel bepaalt dat er een door de staat geregelde fonds zal worden opgericht om Bitcoin en andere cryptocurrencies te beheren.</p>
<p>🔥Volgens Cointelegraph overweegt het Amerikaanse Department of Housing and Urban Development (HUD) te experimenteren met blockchain en stablecoins in sommige van zijn functies.</p>
<p>🔥Volgens CoinDesk breidt de financiële toezichthouder van Thailand, de Securities and Exchange Commission (SEC), zijn lijst van goedgekeurde cryptocurrencies uit om twee belangrijke stablecoins, <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a>‘s USDT en Circle’s USDC, op te nemen als handelsparen op digitale activabeurzen.</p>
<p>🔥Volgens Bitcoin.com News heeft de Caymaneilanden haar crypto-regelgevingskader bijgewerkt en nieuwe vergunningsvoorschriften opgesteld, die vanaf 1 april 2025 van kracht zullen worden. Volgens de Wet op virtuele activa (dienstverleners) (wijziging) 2025, moeten alle entiteiten die virtuele activabewaring en handelsplatformdiensten aanbieden een vergunning verkrijgen die is afgegeven door de Caymaneilanden Monetaire Autoriteit (CIMA). Bestaande aanbieders van virtuele activadiensten (VASP’s) moeten binnen 90 dagen na de ingangsdatum een vergunningsaanvraag indienen.</p>
<p>🔥 Volgens CoinDesk heeft El Salvador een samenwerkingsovereenkomst bereikt met Paraguay over de regulering van crypto. Dit is het tweede internationale crypto-reguleringsakkoord dat het land in drie maanden heeft ondertekend, en een soortgelijke overeenkomst is bereikt met Argentinië.</p>
<p>🔥US SEC-documenten tonen aan dat de U.S. Securities and Exchange Commission (SEC) de goedkeuring van meerdere crypto spot ETF-aanvragen, waaronder Grayscale Spot, heeft uitgesteld <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>(ADA) ETF, Canary Spot <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF, Canary Spot <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF, Canary Spot <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ETF en VanEck Spot <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF.</p>
<p>🔥Volgens IBTimes zal de U.S. Securities and Exchange Commission (SEC) een voorstel ueren om de definitie van ‘beurs’ te bepalen om te bepalen of de definitie kan worden aangepast om entiteiten of bedrijven uit te sluiten die crypto-handel toestaan, wat een andere verschuiving markeert in de nieuwe strategie van de SEC voor het omgaan met cryptocurrencies en digitale activa.</p>
<p>🔥Volgens Cointelegraph heeft de Amerikaanse senator Cynthia Lummis het Bitcoin Act (Boosting Innovation, Technology, and Competitiveness through Optimized Investment Nationwide Act of 2025) opnieuw ingediend bij het 119e Congres. Het wetsvoorstel zal de Amerikaanse overheid toestaan om meer dan 1 miljoen bitcoins in bezit te hebben.</p>
<p>🔥Volgens The Block kondigde de financiële toezichthouder van Zuid-Korea woensdag aan dat het van plan is om uitgebreide richtlijnen uit te vaardigen voor institutionele cryptoinvesteringen in het derde kwartaal.</p>
<p>🔥Volgens de officiële aankondiging heeft de Centrale Bank van Rusland, in overeenstemming met de instructies van de Russische president, een voorstel ingediend bij de regering voor bespreking over het reguleren van crypto-investeringen. Het voorstel suggereert dat een beperkte groep Russische investeerders cryptocurrencies mag kopen en verkopen.</p>
<p>🔥Indiase autoriteiten hebben onlangs Aleksej Bešciokov gearresteerd, mede-oprichter van de gesanctioneerde cryptobeurs Garantex, die sinds de oprichting in 2019 meer dan $60 miljard aan illegale kapitaalstromen heeft verwerkt.</p>
<p>🔥De U.S. Securities and Exchange Commission (SEC) heeft dinsdag zijn beslissing over verschillende aanvragen voor spot crypto ETF’s uitgesteld, waaronder <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL), <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE), and <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> (LTC).</p>
<h2 id="h2-Crypto20Markt20Highlights843162"><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 daling van de cryptomarkt verder geïntensiveerd. Beïnvloed door de macro-economie en de top van het Witte Huis, zijn externe factoren zoals de Amerikaanse aandelenmarkt ook de afgelopen week blijven dalen, wat de cryptomarkt heeft beïnvloed en heeft geleid tot een verdere daling van de algehele markt. De meeste mainstream munten hebben de afgelopen week een voortdurende neerwaartse trend laten zien. Over het algemeen is de mogelijkheid van een snelle marktherstel op korte termijn in de nabije toekomst laag, en er is nog steeds een trend van verdere daling in de toekomst.</p>
<p>⭐️Deze week stond de toename van TIA op de cryptomarkt op de eerste plaats tussen de mainstream munten, maar in feite bereikte de stijging van de munt niet een hoog niveau. De werkelijke stijging van de mainstream munten was ongeveer 8%. Na de daling aan het begin van de week was het korte termijn herstelmomentum van de munt niet sterk. De huidige prijs bleef rond de $3.4. Er was een relatief duidelijke continue fluctuatietrend zichtbaar en er is nog steeds een bepaalde neerwaartse trend.<br><img src="https://gimg2.gateimg.com/image/article/17419182701.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties144204"><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-Bitcoin20BTC126600"><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/17419182912.jpeg" alt=""><br>(Data Courtesy Of TradingView)</p>
<p>Deze week is de prijs van BTC voortdurend aan het dalen sinds de opening. Aangezien de top in het Witte Huis niet het verwachte effect heeft gehad, is de markt dienovereenkomstig gedaald. Bovendien heeft de daling van de Amerikaanse aandelenmarkt ervoor gezorgd dat de prijs van BTC duidelijker daalde. Deze ronde van daling heeft echter over het algemeen impact op de markt, maar de prijs van BTC is relatief sterk. De prijs is niet onder de sleutelprijs van $75.000 gedaald en er is daarna een lichte opleving geweest. De prijs van BTC is weer boven de $80.000 gestegen, maar er bestaat nog steeds de mogelijkheid van verdere daling. De verdere prestaties van de BTC-prijzen zijn afhankelijk van de algemene markttrendwijzigingen, macro-economische en beleidsfactoren.</p>
<h3 id="h3-Ethereum20ETH673157"><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/17419183263.jpeg" alt=""><br>(Data Courtesy Of TradingView)</p>
<p>De prijstrend van ETH deze week is vergelijkbaar met die van BTC, die ook sterk wordt beïnvloed door externe nieuwsfactoren. De prijsprestaties zijn echter niet zo sterk als die van BTC. Na de snelle prijsdaling is er geen duidelijk herstel en schommelt de prijs in principe in het bereik van $1,800-$1,900. De prijs van ETH ligt rond de $1,850 en blijft in een kleine marge stijgen en dalen. Het hoogtepunt van de prijs van ETH deze week ligt rond de $2,200 tijdens de openingsperiode. Verwacht wordt dat er tijdens het weekend een nieuwe ronde van prijsschommelingen zal zijn en de kans op verdere daling relatief hoog is.</p>
<h2 id="h2-Web320Project20Trend189119"><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 marktwaarde van de zeven soorten projecten over de hele linie. De neerwaartse trend van de meeste tracks is verder geïntensiveerd en scherpe dalingen komen vaker voor. De algehele markt is de afgelopen tijd sterk beïnvloed door nieuwsfactoren en de macro-economie, en het is waarschijnlijk dat het op korte termijn verder zal dalen.</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.9%</td>
<td>KTA,SOUL,ZTH</td>
<td>De totale marktwaarde van de Layer 1-sector daalde scherp. De verdeling van de groei van de topmunten was relatief vergelijkbaar, met een dynamische verdeling van ongeveer 50%, en de meeste projecten in de sector vertoonden een neerwaartse trend.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>-13.9%</td>
<td>LAI, OPAI, ISLM</td>
<td>De Layer 2-track bleef dalen en de daling werd verder geïntensiveerd. Onder de top stijgende munten presteerde LAI het beste, met een sterke stijging gedurende twee opeenvolgende weken. Andere munten hadden kleinere stijgingen en de algehele trackmarkt handhaafde een neerwaartse trend.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-15.0%</td>
<td>DEPAY,PRISMA,TERMINAL</td>
<td>De totale marktwaarde van de DeFi-sector is aanzienlijk gedaald en bevindt zich over het algemeen in een voortdurende neerwaartse trend. De winsten van de topmunten zijn ook relatief beperkt.</td>
</tr>
<tr>
<td>NFT</td>
<td>-17.3%</td>
<td>XED,$RAINI,RMV</td>
<td>De totale waarde van de NFT-markt is aanzienlijk gedaald. De top stijgende munten waren voornamelijk niet-mainstream munten, en de verdeling van de winsten was uiterst onevenredig.</td>
</tr>
<tr>
<td>MEME</td>
<td>-18.6%</td>
<td>ANTI,CATEX,FOFAR</td>
<td>De neerwaartse trend van de MEME-muntbaan werd verder geïntensiveerd, maar de stijging van de top stijgende munten bereikte nog steeds 1000%. De algemene marktsituatie is echter dat de meeste munten een neerwaartse trend vertonen.</td>
</tr>
<tr>
<td>Vloeibaar Staken</td>
<td>-17.2%</td>
<td>PRISMA,STSOMM,OS</td>
<td>De neerwaartse trend van deze sector werd geïntensiveerd, en de groei van de topmunten was geconcentreerd in individuele munten, die sterk werden beïnvloed door de trends van mainstreammunten.</td>
</tr>
<tr>
<td>AI</td>
<td>-18.6%</td>
<td>LAI,VNTR,TERMINAL</td>
<td>De AI-track handhaafde een scherpe daling en de winsten van de topmunten bleven matig. De algehele baan is onlangs beïnvloed door marktfluctuaties en de recente trage trend zet zich voort.</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 zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>