V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgQ3J5cHRvY3VycmVuY3ktbWFya3Qgb25kZXJ2aW5kdCBkZXplIHdlZWsgZWVuIGZsdWN0dWVyZW5kZSBkYWxpbmc7IEJUQyBTcG90IEVURidzIHdvcmRlbiBnZWNvbmZyb250ZWVyZCBtZXQgdm9vcnRkdXJlbmRlIG5ldHRvc3Ryb21lbg==

<p><img src="https://gimg2.gateimg.com/image/article/1711095466zb.jpeg" alt=""></p>
<h2 id="h2-Wekelijks20trendoverzicht156079"><a name="Wekelijks trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks trendoverzicht</h2><p>Deze week zag een neergang op de cryptomarkt, met een aanzienlijke dagelijkse daling onder de belangrijkste cryptocurrencies. Ondanks een lichte opleving tegen het einde van deze week, is de markt niet teruggekeerd naar de gunstigere omstandigheden die in de voorgaande twee weken werden gezien. Het marktsentiment staat nog steeds hoog op 80 punten, wat een algemeen optimistische stemming weerspiegelt. De totale marktkapitalisatie bedraagt ​​$ 2,46 biljoen, wat een stijging van 1,28% betekent in de afgelopen 24 uur. Gangbare cryptocurrencies zijn onderhevig geweest aan grillige schommelingen, waarbij de huidige prijzen lager zijn dan hun openingsprijs van de week. Over het algemeen heeft de markt scherpe schommelingen ervaren, veroorzaakt door het afwikkelen van aanzienlijke longposities, negatief nieuws en de terugtrekking van over-the-counter (OTC) fondsen, wat heeft geleid tot een over het algemeen slechte prestatie voor de meeste valuta’s.</p>
<p>Deze week zag de cryptocurrency-markt een aanhoudende daling van het totale handelsvolume in vergelijking met vorige week. Reguliere valuta’s, die eerder een piek hadden bereikt, ondergingen een aanzienlijke daling, als gevolg van de trend in het totale marktvolume. Desondanks bereikten sommige sectoren binnen de markt nieuwe hoogtepunten in zowel het handelsvolume als de prijzen, hoewel de meeste sectoren opmerkelijke dalingen kenden. Nu het weekend ten einde loopt, is er een opleving in de algemene markttrend. Vooruitkijkend wordt verwacht dat de markt tijdens het weekend aanzienlijke verschuivingen zal meemaken, met een grote kans op een bescheiden stijging.</p>
<p>De top 100 cryptocurrencies deze week tonen een verhouding van winnaars ten opzichte van verliezers van ongeveer 20:80. In lijn met het algemene bearish sentiment op de markt is de meerderheid van de mainstream valuta’s naar beneden getrend. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) doorbrak opmerkelijk verschillende kritieke ondersteuningsniveaus, dook onder de $61.000 grens voor een tijdje en noteerde een wekelijkse verandering van -7,39%; het handelt nu in de buurt van $64.848. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH) weerspiegelde deze volatiliteit en zakte kort onder de $3.100, met een wekelijkse daling van -10,09%, waarbij de prijs momenteel rond de $3.432 ligt</p>
<p>In een week die werd gekenmerkt door wijdverspreide marktdalingen, heeft ONDO zich onderscheiden met een indrukwekkende groei van 35,2% in 7 dagen, nu gewaardeerd op ongeveer $0,7353 en wordt het bekroond als de grootste stijger van de week.</p>
<p>De cryptocurrency markt van deze week heeft aanzienlijke schommelingen en algemene neerwaartse trends gezien. Naar het einde van de week toe heeft er een lichte stijging plaatsgevonden, maar het is een bescheiden verbetering. De markt past zich momenteel aan tijdens een correctie fase. In de komende paar weken is het minder waarschijnlijk dat de totale marktkapitalisatie en belangrijke cryptocurrency prijzen terug zullen klimmen naar de recente hoogtepunten. Voortdurende observatie is nodig om te bepalen hoe de markt zich zal ontvouwen.</p>
<h2 id="h2-crypto20markt868109"><a name="crypto markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>crypto markt</h2><p>🔥Beïnvloed door de liquidatie van massale longposities en ongunstig nieuws daalde de markt deze week aanzienlijk.<br>🔥Toen de week begon, zagen we recordprestaties op verschillende projecten, met pieken in NDR- en PRIME-prijzen, een stijging in de marktkapitalisatie van SOL en een recordhoogte in transactievolumes voor. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> BonkBot van , een groeiende zoekinteresse voor <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> op Google Trends en ongekende dagelijkse transacties op Base. Spot BTC en ETF’s in de VS zagen hun hoogste wekelijkse nettostromen en handelsvolumes in de afgelopen week, en de digitale activa-investeringsproducten kenden ook de grootste wekelijkse nettostromen. De MEME-manie op Solana hield aan en de AI-sector maakte een algemene stijging mee.<br>🔥Op basis van de gegevens van maandag hebben de cumulatieve opbrengsten uit alle Meme coin-projecten in de afgelopen 72 uur de $100 miljoen bereikt.<br>🔥Deze week overtrof SOL tijdelijk. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, die de positie van de op drie na grootste cryptocurrency qua marktwaarde claimde, voordat <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> zijn positie herwon.<br>🔥Door een fout van het Slerf-team zijn de fondsenwervende LP Token en airdrop-tokens vernietigd en kunnen ze niet worden hersteld, wat leidt tot ernstige schommelingen in de marktprestaties van Slerf. De oprichter van Slerf heeft verzekerd dat het team actief op zoek is naar oplossingen voor dit probleem en zich inzet om het goed te maken met de bijdragers aan de voorverkoop. Desalniettemin is het meest urgente probleem het gebrek aan voldoende middelen om terugbetalingen te doen aan de deelnemers aan de voorverkoop.<br>🔥Verschillende projecten hebben plannen aangekondigd om airdrop-tokens uit te delen aan degenen die hebben deelgenomen aan de SLERF-verkoop.<br>🔥De portemonnee van El Salvador heeft bijna 200 donaties in BTC ontvangen.<br>🔥NodeMonkes heeft Boring Ape NFT in marktwaarde ingehaald en claimt de plek als de op een na grootste NFT qua marktkapitalisatie.<br>🔥ether.fi airdrop is nu open voor claim.<br>🔥In de loop van de week bereikten BTC-spot-ETF’s een nieuw hoogtepunt in netto-uitstroom op één dag, terwijl GBTC getuige was van de grootste opname op één dag ooit; dit viel samen met een algemene neergang van de markt en een daling van de Amerikaanse crypto-aandelenkoersen.<br>🔥Het 24-uurs handelsvolume van SLERF op de Solana-keten bedroeg meer dan $ 2,2 miljard, de tweede alleen voor SOL en USDC.<br>🔥Volgens de statistieken op de 19e bevinden de top drie DEX’s op basis van 24-uurs handelsvolume zich allemaal op de Solana-keten, namelijk Raydium, Jupiter en Orca.<br>🔥De New York Times meldde dat ongeveer 30% van ‘s werelds blockchain-game goudzoekers gevestigd zijn in de Filippijnen.<br>🔥Bitcoin Spot ETF registreerde gedurende opeenvolgende dagen een grote netto-uitstroom, waarbij blockchain-gerelateerde aandelen over het algemeen daalden. Op 19 maart zagen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF’s een netto-uitstroom van $ 326 miljoen, gevolgd door een uitstroom van $ 500 miljoen op de 20e, en een extra uitstroom van $ 261,5 miljoen werd opnieuw geregistreerd op de 20e.<br>🔥 <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> De 4 miljoen dollar steun van Starbucks voor de cryptotoegang is tekortgeschoten en is mislukt.<br>🔥Binnen 24 uur op 20 maart werden posities ter waarde van $666 miljoen geliquideerd.<br>🔥Een ETF-analist van Bloomberg voorspelt dat de kans op goedkeuring van een <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF op de spotmarkt in mei klein is.<br>🔥Grayscale GBTC zag op 19 maart een uitstroom van 444 miljoen dollar.<br>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft nog eens 1 miljard USDT uitgegeven op de <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> netwerk (geautoriseerd maar nog niet uitgegeven).<br>🔥NFTfi lanceert de NFTfi Foundation en zal de DAO lanceren via de NFTfi Council.<br>🔥0n 19 maart registreerde Bitcoin zijn grootste eendaagse daling sinds de ineenstorting van FTX, waarbij de prijs op één dag met meer dan 8% daalde.<br>🔥Het cumulatieve handelsvolume van de Amerikaanse spot Bitcoin ETF bedroeg meer dan 150 miljard dollar.<br>🔥Grayscale Ethereum Trust korting bereikt laagste niveau sinds november 2023.<br>🔥Robinhood lanceert zijn crypto-portemonnee voor Android-gebruikers over de hele wereld.<br>🔥Er waren marktgeruchten die suggereerden dat de Ethereum Foundation werd onderzocht door de overheid in een land, maar CEHV-partners verduidelijkten later dat het nieuws vals was.<br>🔥In de afgelopen week was de Base-keten getuige van een toestroom van meer dan 840.000 nieuwe gebruikers, een aanzienlijke stijging van 510% ten opzichte van de week ervoor.<br>🔥Mystiko Network, de basislaag van Web3, voltooide $ 18 miljoen aan startrondefinanciering.<br>🔥CryptoPunk #7804 verkocht voor meer dan $ 16 miljoen aan ETH.<br>🔥Grayscale GBTC had op 20 maart een netto-uitstroom van 386 miljoen dollar geregistreerd.<br>🔥De halvering van BTC zal naar verwachting op 20 april worden voltooid, met een aftelling van minder dan 30 dagen.<br>🔥Global X lanceert binnenkort de BTC futures strategy ETF met de code BTRN.<br>🔥De totale marktwaarde van stablecoins op de cryptomarkt heeft de 150 miljard dollar overschreden.<br>🔥De totale claims van de Amerikaanse regering tegen FTX zullen naar verwachting tussen de $3 miljard en $5 miljard liggen.</p>
<h2 id="h2-Regelgevingsbeleid566021"><a name="Regelgevingsbeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevingsbeleid</h2><p>🔥Na 17 jaar heeft de Bank of Japan de rentetarieven verhoogd en de referentierente verplaatst van -0,1% naar een bereik van 0 tot -0,1%, waarmee het tijdperk van negatieve rentetarieven ten einde komt. Er wordt verwacht dat er voor de nabije toekomst een relatief accommoderend monetair klimaat zal worden gehandhaafd.</p>
<p>🔥荷兰当局指控亚历克谢·佩尔采夫通过Tornado Cash帮助洗钱12亿美元。</p>
<p>SBF heeft betoogd dat het voorstel van Amerikaanse aanklagers om hem mogelijk aan maximaal 50 zinnen te onderwerpen, een vertekening van de werkelijkheid is.</p>
<p>🔥De Amerikaanse SEC is begonnen met een juridische campagne om Ethereum te classificeren als een effect.</p>
<p>🔥De Federal Reserve heeft de rentetarieven ongewijzigd gelaten, waarbij de voorzitter verklaarde dat hoewel er een aanzienlijke daling van de inflatie is geweest, deze nog steeds boven de streefniveaus ligt, waardoor de mogelijkheid van een renteverlaging later in het jaar wordt geopend. Hij benadrukte ook dat de Fed niet in het geheim de creatie van CBDC bevordert.</p>
<h2 id="h2-Hoogtepunten20van20de20cryptomarkt700576"><a name="Hoogtepunten van de cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoogtepunten van de cryptomarkt</h2><p>⭐️Afgelopen week heeft de cryptocurrency-markt een overheersende neergang gezien, waarbij het merendeel van de week werd gekenmerkt door rode kaarsen. Er is echter een lichte opleving geweest nu de week ten einde loopt, wat een sprankje hoop biedt voor het handelsactiviteit in het weekend. Na een periode van snelle groei de afgelopen weken is er een groeiend gevoel dat de markt oververhit kan zijn geweest. De neergang in de prijzen van grote valuta’s heeft geleid tot aanzienlijke liquidaties van longposities. Dit, samen met wijdverbreide liquidaties en aanhoudende grote uitstroom uit BTC spot ETF’s, heeft bijgedragen aan de markttraagheid van deze week. Momenteel ondergaat de cryptomarkt een periode van consolidatie en aanpassing, met mogelijk opvallende trendverschuivingen in de komende week.</p>
<p>⭐️ De markt heeft deze week zijn neerwaartse traject voortgezet, waarbij tal van valuta deze daling weerspiegelen. Ondanks een gebrek aan bullish nieuws binnen de cryptowereld, heeft de Amerikaanse fondsmarkt verschillende positieve verschuivingen doorgemaakt als gevolg van recente beleidsmaatregelen van de Federal Reserve. Deze verschuivingen hebben met name Ondo ten goede gekomen, dat gespecialiseerd is in de tokenisatie van real-world assets (RWA). De stijging van Ondo met 35,2% komt mogelijk niet overeen met de recente stijgingen die te zien zijn geweest in de valuta van de MEME-sector, maar het blijft een opmerkelijke uitzondering in de bearish trend, met een prijs die rond de $0.7353 schommelt. Naast externe marktfactoren kan de opwaartse beweging van Ondo ook worden toegeschreven aan zijn korte emissiecyclus en het optimistische marktsentiment ten opzichte van zijn potentie als een opkomende cryptocurrency.<br><img src="https://gimg2.gateimg.com/image/article/17110955971.jpeg" alt=""><br>(Data bronnen: <a href="https://coinmarketcap.com/" rel="nofollow noopener noreferrer" target="_blank">Coinmarketcap</a>)</p>
<h2 id="h2-Bitcoin20amp20Ethereum20Wekelijkse20Prestatie617889"><a name="Bitcoin &amp; Ethereum Wekelijkse Prestatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin &amp; Ethereum Wekelijkse Prestatie</h2><h3 id="h3-Bitcoin20BTC598221"><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/17110956192.jpeg" alt=""><br>(Bronnen: <a href="https://www.tradingview.com/" rel="nofollow noopener noreferrer" target="_blank">TradingView</a>)<br>Sinds het begin van de week bevindt BTC zich in een neerwaarts traject en gaat vervolgens een fase van aanzienlijke en scherpe aanpassingen in. De prijs zag een dramatische daling van $ 69.000 naar $ 61.000 in een kort tijdsbestek, met de grootste daling op één dag van meer dan 8%. Momenteel bevindt BTC zich in een consolidatiefase en houdt het actieve dagelijkse fluctuaties aan. Naarmate het einde van de week nadert, wordt een mogelijke trendverandering verwacht.<br>Analisten zijn van mening dat de BTC deze week verschillende belangrijke ondersteuningsniveaus heeft afgebroken, wat heeft geleid tot massale liquidaties, wat een grotere impact heeft op de markt. Gecombineerd met de massale uitstroom van OTC ETF-fondsen, is BTC in een relatief trage trend terechtgekomen. In combinatie met de op handen zijnde halvering kan het enige tijd duren voordat de valuta terugkeert naar boven de $ 70.000, wat alleen haalbaar is met substantiële veranderingen in zowel de interne als de externe marktdynamiek.</p>
<h3 id="h3-Ethereum20ETH707625"><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/17110956793.jpeg" alt=""><br>(Data bronnen: <a href="https://www.tradingview.com/" rel="nofollow noopener noreferrer" target="_blank">TradingView</a>)</p>
<p>De prijsbeweging van ETH deze week heeft die van BTC gespiegeld. Net als BTC zag ETH een snelle daling toen de markt openging. Na onder de $3.100 te zijn gedaald, heeft het sindsdien enig herstel gezien. Gedurende het grootste deel van de week zijn de prijsfluctuaties van ETH iets milder geweest in vergelijking met die van BTC, waarbij het erin slaagde boven het cruciale ondersteuningsniveau van $3.000 te blijven. Momenteel zwevend rond $3.500, wordt verwacht dat ETH een opleving zal ervaren wanneer het weekend ten einde loopt.</p>
<p>Analisten stellen dat de recente prestaties van ETH niet alleen in lijn zijn met de bredere neergang op de cryptomarkt, maar ook gedeeltelijk te wijten zijn aan de regelgevende houding van de SEC ten opzichte van ETH. De afwijzing van ETP-aanvragen met betrekking tot Ethereum, samen met de handhavingsmaatregelen van de SEC gericht op de munt, hebben een schaduw geworpen over de ETH-markt. Gezien deze omstandigheden voorspellen analisten dat het moeilijk zal zijn voor ETH om op korte termijn terug te keren naar het prijspunt van $ 4.000.</p>
<h2 id="h2-Web320Project20Trends822291"><a name="Web3 Project Trends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trends</h2><p>De afgelopen week hebben de negen toonaangevende sectoren binnen de Web 3-ruimte een sterke daling van de marktwaarde gezien. Met de markt die een algemene bearish trend omarmt, valt Solana MEME op als de uitzondering, waarbij een algehele groeitraject wordt gehandhaafd. De meeste andere projecten hebben echter scherpe neergangen gekend, waarbij allemaal snelle dalingen vertonen, en de vooruitzichten op een snelle en substantiële herstel lijken mager.<br><img src="https://gimg2.gateimg.com/image/article/17110957611.png" alt=""><img src="https://gimg2.gateimg.com/image/article/17110957832.png" alt=""><img src="https://gimg2.gateimg.com/image/article/17110958023.png" alt=""></p>
<div class="blog-details-info"><br><div>Auteur:<strong> Charles T.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is 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>