V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgRGUgY3J5cHRvLW1hcmt0IGhlZWZ0IHNjaG9tbWVsaW5nZW4gZW4gb3B3YWFydHNlIGJld2VnaW5nZW4gZXJ2YXJlbjsgQlRDIFNwb3QgRVRGIGRvb3JicmVla3QgZGUgdHJlbmQgdmFuIG5ldHRvc3Ryb29tIGdlZHVyZW5kZSA1IG9wZWVudm9sZ2VuZGUgZGFnZW47IEJFVk0gTWFpbmV0IGd

2024-03-29, 01:56

<p><img src="https://gimg2.gateimg.com/image/article/1711677358zb.jpeg" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht765189"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>De algehele cryptomarkt is deze week hersteld, maar het proces gaat nog steeds gepaard met bepaalde schommelingen. De algehele amplitude is echter niet significant, en het is weer gestegen in de slotperiode in de buurt van het weekend. De algehele marktwaardegroei is echter niet bijzonder groot in vergelijking met dezelfde periode vorige week, met een stabilisatie rond de $2,65 biljoen, een toename van 1,66% in 24 uur. De marktsentiment blijft boven de 80 punten en blijft optimistisch. De meeste van de belangrijkste mainstream valuta’s hebben deze week een stijgende trend laten zien, maar behalve voor enkele sectorvaluta’s hebben de meerderheid van de valuta’s hun stijgende trend binnen relatief kleine gebieden gehandhaafd, over het algemeen onder de 10%. Over het algemeen, als gevolg van de marktdaling vorige week, bevindt de cryptomarkt zich deze week nog steeds in een periode van aanpassing en wordt verwacht dat er dit weekend een aanzienlijk algemeen herstel zal plaatsvinden.</p>
<p>Vergeleken met vorige week heeft de totale crypto-markt deze week een stijgende trend laten zien, maar deze ging gepaard met een volatiele terugval. De stijging van specifieke mainstream valuta’s is echter meer uitgesproken, zoals de duidelijke stijging van 44% in de week voor DOGE. Op dit moment, naarmate het weekend nadert en de halvering van BTC nadert, blijft het algemene bullish sentiment in de markt overheersen. Er wordt verwacht dat er een stijgende trend zal zijn gedurende het weekend, gevolgd door een lichte terugval na voortdurende stijging tot volgende week.</p>
<p>De top 100 crypto-projecten hebben een stijging- en dalingverhouding van ongeveer 80:20 binnen een week, en de meeste mainstream valuta’s hebben deze week een stijgende trend op de markt laten zien, wat nauw verband houdt met het algehele herstel van de markt. De BTC-prijs is binnen een week gestegen naar boven de $70.000, met een wekelijkse stijging of daling van ongeveer 7,75%. Op dit moment blijft het schommelen rond $70.797. De ETH-markt is vergelijkbaar deze week, maar met grotere volatiliteit. Het wekelijkse dieptepunt van de prijs is onder de $3.300 gezakt, met een algehele stijging van ongeveer 2,27%. Op dit moment blijft het rond de $3.553 en blijft het schommelen.</p>
<p>De marktprestaties van deze week waren nog steeds relatief hoog in het MEME-segment, met een stijging van 46,01% in WIF in 7 dagen. De munt prijs wordt momenteel gehandhaafd rond $3.36, wat de eerste plaats inneemt in een week van winsten.</p>
<p>Hoewel de algehele cryptomarkt deze week tot op zekere hoogte is hersteld, is de verdeling van de opwaartse trend ongelijk en niet overal. Sommige valuta’s bevinden zich nog steeds in een duidelijke neerwaartse trend, en het is zeer waarschijnlijk dat de markt een aanvullende opwaartse trend nodig heeft gedurende het weekend om de algehele trend te stimuleren.</p>
<h2 id="h2-Crypto20Markt781318"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥 Deze week kende de cryptomarkt prijsschommelingen, met een lichte terugval halverwege de week na een opleving.</p>
<p>🔥 Meerdere sectoren zagen maandag een opwaartse trend, met BTC+4,0% en ETH+3,6% in 24 uur; PENDLE prijs, ONDO prijs, AERO prijs, DEGEN prijs en Base gebruiker wekelijkse nieuwe recordhoogtes; Base ecosysteem MEME en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het ecosysteem MEME is over het algemeen in opkomst.</p>
<p>🔥 Deze week worden tokens zoals $84,32 miljoen OP, $37,53 miljoen PRIME, $16,89 miljoen YGG, $9,26 miljoen AGIX, $6,68 miljoen SUI en $900.000 ACA ontgrendeld.</p>
<p>🔥 Negentropie belooft $1 miljoen te doneren aan Slerf om zijn NFT te ondersteunen.</p>
<p>🔥 PUMP is vanavond open voor handel, met een marktwaarde van $12,9 miljoen op basis van de initiële liquiditeit.</p>
<p>🔥 MEME heeft de Base TVL aangedreven om de $2 miljard te overschrijden, met een dagelijks handelsvolume van DEX op de Base-keten dat gedurende een week meerdere opeenvolgende dagen $200 miljoen heeft overschreden.</p>
<p>🔥 De Base-protocolmanager verklaarde dat de ERC20-migratietool BaseMigrate zal worden uitgebracht.</p>
<p>🔥 Scroll Co Creation heeft aangekondigd dat het binnen enkele maanden 4844, DA Compression, Proof Aggregation en meer zal lanceren.</p>
<p>🔥 PENDLE FDV heeft deze week de grens van $1 miljard overschreden.</p>
<p>🔥 Circle-bestuurders interpreteren EU-regelgeving inzake antiwitwaspraktijken: de impact op zelfbeheerde portefeuilles en CASP is zeer beperkt.</p>
<p>🔥 UniCross heeft aangekondigd dat de uitgifte van RUFI Mint is opgeschort vanwege congestie op het Merlin-netwerk.</p>
<p>🔥 Een bepaald adres heeft 1558,8 SOL gedoneerd aan SLERF als compensatie voor de overdracht van de portemonnee.</p>
<p>🔥 De London Stock Exchange zal BTC- en ETH-ETN-aanvragen accepteren vanaf 8 april en van plan zijn om ETN-handel te starten op 28 mei.</p>
<p>🔥 <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> plannen om FVM parallel te laten lopen en financiering uit te breiden voor Sonic Labs, en de investering zal in de komende weken worden bekendgemaakt.</p>
<p>🔥 Curio Ecosysteem werd aanglen, wat resulteerde in een verlies van $16 miljoen.</p>
<p>🔥 Vitalik mentioned ENS in his post.</p>
<p>🔥 Musk vroeg aan Vitalik waarom hij het X-platform heeft verlaten.</p>
<p>🔥 FTX zal tweederde van zijn aandelen in Aerospace verkopen voor $884 miljoen.</p>
<p>🔥 BRC20 zal binnenkort 5 tekens ondersteunen en MINT implementeren.</p>
<p>🔥 Het Blast Eco Munchables zijn aanglen, wat resulteerde in een verlies van $62,3 miljoen, maar ze zijn volledig hersteld.</p>
<p>🔥 Gedurende de week was er een lichte correctie op de markt, waarbij BTC -1,6% en ETH -2,9% daalden; de prijs van SUI, de prijs van ALT, de prijs van ETHFI, de prijs van NAVX, de prijs van WEN, Base TVL, de aandelenkoers van MicroStrategy en de marktwaarde van BlackRock IBIT BTC-holdings hebben historische hoogtepunten bereikt; de RWA-sector steeg over het algemeen.</p>
<p>🔥 Deze week kondigden ongeveer 20 projecten aan (gepland) de voltooiing van meer dan $230 miljoen aan financiering.</p>
<p>🔥 Binnen een week brak BTC spot ETF de trend van netto uitstroom gedurende vijf opeenvolgende dagen.</p>
<p>🔥 Casey verklaarde dat als de marktwaarde van het Runes-ecosysteem niet binnen de eerste maand van de lancering $1 miljard bereikt, ze bereid is seppuku te plegen.</p>
<p>🔥 Vitalik Buterin uit steun voor gedecentraliseerde inzet via meer anti-gerelateerde prikkels; Accountabstractie biedt beveiliging en gemak voor ontwikkelaars en gebruikers; Farcaster-informatie wordt niet opgeslagen in de blockchain en kan de beveiliging en schaalbaarheid verbeteren; De definitie van het metaversum is nog steeds vaag en vereist een combinatie van cryptocurrency, virtual reality en AI.</p>
<p>🔥 De non-profitorganisatie FLI heeft bekendgemaakt dat zij een donatie van $665 miljoen SHIB van Vitalik Buterin heeft ontvangen.</p>
<p>🔥 Grayscale Chief Legal Officer: De SEC heeft geen diepgaande discussies gevoerd over ETH spot ETF’s vanwege de consensus die is bereikt over gerelateerde kwesties met betrekking tot BTC ETF’s.</p>
<p>🔥 GameFi Illuvium brengt een nieuwe routekaart en details uit voor Private Beta 4.</p>
<p>🔥 Bij het naderen van het weekend sluitingsfase, BTC+1,4% in 24 uur, ETH+0,8%; ETHFI-prijs, ETH-liquiditeit herbelening TVL, Basistvl, Blast TVL, Sui TVL, Deribit BTC optie open rentecontracten vervallen in maart, dagelijkse netto instroom van ARKB bereikt een historisch hoogtepunt; dagelijkse netto instroom van Fuda FBTC bereikt een nieuw dieptepunt.</p>
<p>🔥 Deze week kondigden in totaal 9 projecten financiering aan die meer dan $100 miljoen overschrijden.</p>
<p>🔥 De Amerikaanse BTC-spot ETF had gisteren een nettostroom van $254 miljoen.</p>
<p>🔥 Oprichter Casey van Ordinals heeft het Runes-document aangekondigd, waarin een monument-upgrademechanisme wordt geïntroduceerd.</p>
<p>🔥 MerlinSwap is begonnen met het airdroppen van esMP tokens; De MP token IDO is geëindigd, met een inschrijvingsbedrag van meer dan $480 miljoen.</p>
<p>🔥 Het BEVM-mainnet is deze week gelanceerd.</p>
<p>🔥 <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> De kapitaaluitstroom van het EVM-keten van ‘s werelds is gestegen tot $1,78 miljard.</p>
<p>🔥 Arbitrum en Azuki hebben samengewerkt om het anime-netwerk AnimeChain te lanceren.</p>
<p>🔥 Ethena zal 750 miljoen ENA’s uitdelen en CEX lanceren op 2 april.</p>
<p>🔥 Ondo Finance heeft real-time investerings- en terugkoopdiensten geïntroduceerd, met $95 miljoen geïnvesteerd door OUSG Fund in BlackRock’s BUIDL.</p>
<p>🔥 De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blob wordt gebruikt om inies te maken, en er zijn gisteren 2.437 blob-inies gemaakt; De inie drijft de blob aan om de ingestelde gebruiks capaciteitslimiet te bereiken.</p>
<p>🔥 Het Meme-project van Huang Licheng, Bobaopa, heeft $38 miljoen opgehaald in SOL via promotie.</p>
<p>🔥 LADYS lanceert Meme Phone.</p>
<p>🔥 <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, SingularityNET en Ocean Protocol bundelen tokens om een gedecentraliseerde AI-alliantie te vormen.</p>
<h2 id="h2-Regelgevingsbeleid861222"><a name="Regelgevingsbeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevingsbeleid</h2><p>🔥 De verklaring van de Federal Reserve’s Bostic suggereert dat te vroeg doorvoeren van renteverlagingen mogelijk destructiever kan zijn, waarbij dit jaar slechts één renteverlaging wordt verwacht.</p>
<p>🔥 De Amerikaanse SEC is op zoek naar $2 miljard aan boetes en straffen in de <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zaak.</p>
<h2 id="h2-Crypto20Markt20Highlights300038"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐️Afgelopen week werd de algehele trend van de cryptomarkt voornamelijk gedreven door de populariteit van individuele sectoren, en de algehele trend van gerelateerde valuta’s zit nog steeds in een aanpassingscyclus. De meeste cryptocurrencies zijn de afgelopen week een neerwaartse trend ingegaan naarmate het weekend nadert, maar op dit moment is de omvang niet significant en de meeste valuta’s zijn er niet door beïnvloed. De opleving van de BTC-prijzen deze week geeft ook aan dat de markt in de afgelopen week duidelijke opwaartse signalen begint te vertonen, en we kunnen de marktprestaties tijdens het weekend verwachten.</p>
<p>⭐️Verschillende sectoren van de markt hebben het deze week goed gedaan en het wordt verwacht dat de MEME-sector weer zal stijgen. Daarvan presteerde WIF het meest opvallend, met een wekelijkse stijging vergelijkbaar met DOGE. Op dit moment bedraagt de wekelijkse stijging van de munt ongeveer 46% en blijft de prijs binnen het bereik van $3,3. De MEME-sector maakte deze week een sterke opleving door na vorige week te zijn beïnvloed door oververhitting op de markt en het is te verwachten dat het in de toekomst een bepaalde periode van stijgende trend zal blijven handhaven.<br><img src="https://gimg2.gateimg.com/image/article/17116774701.jpeg" alt=""><br>(Data met dank aan Coinmarketcap)</p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties34767"><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-Bitcoin20BTC475732"><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/17116774932.jpeg" alt=""><br>(Data Met Dank Aan TradingView)</p>
<p>De prijstrend van BTC deze week wordt gekenmerkt door aanhoudende volatiliteit na opening, met uitzondering van een korte terugval halverwege de week. Het grootste deel van de tijd is het binnen het bereik van $70.000-$710.000 gebleven en is het voortdurend aan het schommelen. De wekelijkse prijsstijging van de munt is de grootste onder meerdere toonaangevende mainstream valuta’s, en er is momenteel een verdere opwaartse trend. Het wordt verwacht dat het binnenkort opnieuw het prijsniveau van $71.000 zal doorbreken.</p>
<p>Analyse toont aan dat de prijsprestatie van BTC deze week in feite de algemene trend van de markt vertegenwoordigt, namelijk de herstel- en aanpassingscyclus. Hoewel de belangrijkste prijsstijgingen geconcentreerd zijn in andere populaire sectoren, heeft de L2-toepassing landing van BTC-ecosysteem deze week, in combinatie met de naderende halveringstijd, de marktsentiment geïntensiveerd. Daarom is de prijsprestatie begonnen met een aanzienlijke opleving en is een zekere versnellende trend begonnen te vertonen. De weekendafsluitingsfase kan mogelijk verdere aanvulling op de markt brengen.</p>
<h3 id="h3-Ether20ETH510246"><a name="Ether (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ether (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17116775603.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>De prijstrend van ETH deze week blijft een sterke correlatie vertonen met BTC, en maakt een aanhoudende stijging door na opening, tot ongeveer $3.680. De algehele groei is echter nog steeds zwak, met een aanzienlijke daling gevolgd door een lichte opleving tegen het einde van de weekendsluitingsperiode. Momenteel blijft de munt binnen het bereik van $3.500 - $3.600 met lichte schommelingen en wordt er geen significante opwaartse of neerwaartse trend waargenomen.</p>
<p>Analyse suggereert dat de prestaties van ETH-muntprijzen deze week in wezen consistent zijn met de cyclische schommelingen van de markt. Hoewel de algehele trend nog steeds omhoog is, heeft het te maken gehad met regelgevingsgeschillen van de markt, met name van de SEC, wat heeft geleid tot een gebrek aan duidelijke tekenen van herstel voor de munt. Maar het is zeer waarschijnlijk dat er een zekere stijging zal zijn in de slotperiode van het weekend wanneer de algehele markt zich herstelt, maar het kan moeilijk zijn om op korte termijn door de sleutelprijs van $3800 te breken.</p>
<h3 id="h3-Web320Project20Trend675396"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h3><p>De totale marktwaarde van de meeste van de negen categorieën projecten is deze week weer gestegen. Door de schommelingen en aanpassingen van de marktcyclus zijn verschillende sectoren voornamelijk in een opwaartse trend. Met uitzondering van de slechte prestaties van BRC-20 zijn andere soorten projecten opnieuw gestegen, vooral de indrukwekkende prestaties van MEME-gerelateerde sectoren. Het lijkt erop dat er weer een opwaartse cyclus zal zijn tot aan het weekend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1711706418img_v3_029e_1e189bae-cc09-4ea7-bc18-1d634f717bix.jpg" alt=""></p>
<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 opvattingen 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 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>