V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgVG90YWxlIHZvbHVtZSB2YW4gZGUgY3J5cHRvbWFya3QgdmVyYW5kZXJkZSByZWxhdGllZiB3ZWluaWcgaW4gZWVuIHdlZWs7IFZpdGFsaWsgdmVyc2NoZWVuIGluIEhLIG9tIGVlbiB0b2VzcHJhYWsgdGUgZ2V2ZW47IENvbmdlc3RpZXByb2JsZWVtIGluIFNvbGFuYSBuZWVtdCB0b2U=

2024-04-12, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/1712889994zb.jpeg" alt=""></p>
<h2 id="h2-Wekelijks20Trend20Overzicht168725"><a name="Wekelijks Trend Overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trend Overzicht</h2><p>De algehele cryptomarkt handhaafde deze week een relatief kleine schommeling, met een relatief kleine algehele fluctuatie. Binnen een week steeg het eerst en daalde het daarna. Hoewel de algehele verandering niet significant was, was er enige opleving in de buurt van de weekendafsluiting. De algehele groei van de marktwaarde is niet veel veranderd in vergelijking met dezelfde periode vorige week, met een waarde van ongeveer $2,6 biljoen, en is in 24 uur met 0,10% gestegen. De marktsentiment is gestegen tot 76. Deze week hebben belangrijke mainstream valuta’s een gemengde trend van stijging en daling laten zien, maar de meeste mainstream valuta’s hebben een relatief kleine range van stijging en daling gehandhaafd, met over het algemeen voornamelijk fluctuerende schommelingen. Over het geheel genomen heeft de cryptomarkt deze week geen herstel bereikt en bevindt de markt zich nog steeds in een periode van schommelende aanpassing. Er wordt verwacht dat er dit weekend een lichte opleving zal zijn en dat er in de toekomst een hoge waarschijnlijkheid is van een fluctuerende trend.</p>
<p>Vergeleken met vorige week heeft de totale cryptomarkt deze week een lichte daling laten zien, met over het algemeen een langzame stijgende trend sinds de opening. Er was een snelle stijging gedurende de dag, gevolgd door een nieuwe daling tot het einde van het weekend, toen er wat herstel was. De fluctuatieverhouding van de top 100 crypto-projecten binnen een week is 3:7, met de belangrijkste groei voornamelijk gericht op recent populaire valuta, en de prijsveranderingen van de top mainstream valuta’s zijn relatief klein. De BTC-prijs is binnen een week teruggekeerd naar boven de $70.000 en bevindt zich momenteel rond de $70.060, met een wekelijkse stijging of daling van ongeveer 2,44%. ETH is deze week ook enigszins hersteld, met over het algemeen een stijging van ongeveer 5,04%, momenteel een aanhoudende fluctuatie van ongeveer $3.501.</p>
<p>De best presterende munt op de markt deze week was <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, met een stijging van 47,8% in 7 dagen. De muntprijs wordt momenteel gehandhaafd rond $21,94 en staat bovenaan in een week van winsten.</p>
<p>De algehele trend van de crypto markt deze week wordt voornamelijk gekenmerkt door lichte schommelingen, en de ups en downs zijn niet significant. Er zijn nog steeds enkele belangrijke valuta’s met aanzienlijke winsten, en de algehele markt zal waarschijnlijk nog een lichte opleving ervaren tijdens het weekend. Hoewel de trend omhoog is, is de groeisnelheid beperkt.</p>
<h2 id="h2-Crypto20Markt482020"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥 De wekelijkse trend van de cryptomarkt wordt voornamelijk gekenmerkt door volatiele schommelingen, met relatief kleine veranderingen in het totale volume.</p>
<p>🔥 Op maandag steeg BTC met 4,2% en ETH met 6,7% in 24 uur; Top 500 stijging of daling in marktwaarde ≥ 30%: Geen; TON-prijs, Runestone-bodemprijs, Base TVL, Pendle TVL en dagelijks transactievolume Base hebben historische hoogtepunten bereikt.</p>
<p>🔥 Dinsdag 24-uurs BTC -1,7%, ETH+1,1%; De top 500 bedrijven met een marktwaardeverhoging of -verlaging van ≥ 30%: VELO+53%, NEO+32%; TON-prijs, ENA-prijs, ARC-20 token AVM-prijs, Runestone vloerprijs en Base TVL stellen nieuwe historische hoogtepunten in.</p>
<p>🔥 Woensdag 24-uurs BTC -1,9%, ETH -2,9%; Top 500 stijging of daling in marktwaarde ≥ 30%: Geen; BORED-prijzen en Mantle TVL bereikten historische hoogtepunten; Altcoins volgden de algemene daling van de markt, terwijl de Meme-sector over het algemeen daalde.</p>
<p>🔥 Donderdag 24-uurs BTC+2.5%, ETH+2.1%; Top 500 stijging of daling in marktwaarde ≥ 30%: Geen; TON prijs, ENA prijs, PENDLE prijs, RIVUS prijs, Runestone vloerprijs, BTC mining moeilijkheid, Basis TVL bereikt historische hoogtepunten; GBTC’s dagelijkse nettostroom bereikte een nieuw dieptepunt; BRC20 en BTC NFT stegen over het algemeen.</p>
<p>🔥 Het aantal nieuwe adressen toegevoegd aan <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> in maart bereikte een nieuw hoogtepunt sinds november 2021, en de activiteit van langetermijnhouders nam af.</p>
<p>🔥 <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>: UniswapX is gelanceerd op het interface.</p>
<p>🔥 Color Protocol lanceert ERC-404 conversieprotocol voor Meme.</p>
<p>🔥 Atomics Protocol test de ARC20-token splitsingsoplossing.</p>
<p>🔥 De roadmap van TON 2024 wordt gelanceerd, inclusief de lancering van Gasless handel, Wallet v5, nieuwe cross chain technologie Teleport en meer.</p>
<p>🔥 TON lanceert een 1 miljoen <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> sponsorprogramma voor de Chinese gemeenschap.</p>
<p>🔥 Saga kondigt de lancering van de eerste fase van het mainnet aan; De huidige circulerende marktkapitalisatie van SAGA is ongeveer $500 miljoen, met een totale marktwaarde van ongeveer $5.7 miljard.</p>
<p>🔥 De Amerikaanse BTC-spot ETF had gisteren een nettoutstroom van ongeveer $223 miljoen.</p>
<p>🔥 De totale waarde van de BTC-onderpandactiva van USDe heeft de $550 miljoen overschreden.</p>
<p>🔥 Vitalik Buterin verscheen in Hong Kong om een toespraak te houden over het bereiken van de grenzen van protocolontwerp, bouwen op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in de jaren 2020.</p>
<p>🔥 Het steeds erger wordende congestieprobleem in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> heeft vertragingen veroorzaakt bij de start van meerdere projecten op het netwerk.</p>
<p>🔥 TON’s marktwaarde overtrof ADA en werd de op tien na grootste cryptocurrency qua marktkapitalisatie.</p>
<p>🔥 Degen lanceert ‘Deploy on Degen Week’, waarbij meer dan 10 miljoen DEGEN-tokenbeloningen worden aangeboden.</p>
<p>🔥 Farcaster protocol omzet overschreed $1 miljoen.</p>
<p>🔥 Friend.tech heeft een nieuw registratieproces gestart.</p>
<p>🔥 Het percentage van de BTC circulatievoorraad dat gedurende ten minste één jaar niet is overgedragen, bereikte 65,84%, een nieuw laagterecord sinds oktober 2022.</p>
<p>🔥 De Amerikaanse BTC-spot ETF had dinsdag een nettostroom van ongeveer $18,6 miljoen.</p>
<p>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> CEO: Het $500 miljoen BTC-miningplan nadert voltooiing en implementatie.</p>
<p>🔥Worldcoin: Mensen die zich hebben geregistreerd met een World ID kunnen verzoeken om het verwijderen van irisscans.</p>
<p>🔥De oprichter van Jupiter zal spreken op de Token 2049-conferentie en een ‘nieuw dier’ introduceren.</p>
<p>🔥Pandora lanceerde de ERC-404 handelsmarkt Box Protocol.</p>
<p>De financieringsindicator van friend.tech steeg voordat mogelijke airdrops en V2-versies werden uitgebracht.</p>
<p>🔥Sui kondigde de gaming handheld SuiPlay0x1 aan, die naar verwachting volgend jaar zal worden gelanceerd.</p>
<p>🔥 UNI 24-uur -16%, oprichter Adams plaatste dat hij tot het einde zal vechten.</p>
<p>🔥De Amerikaanse BTC-spot-ETF had woensdag een nettostroom van $124 miljoen.</p>
<p>🔥 Deze week bereikte het aantal mijnwerkers dat BTC vasthoudt het laagste niveau sinds het begin van 2021.</p>
<p>🔥Het platformmunt MSTAR IDO van MerlinStarter zal op vrijdag worden gelanceerd.</p>
<p>De oprichter van Marginfi heeft aangekondigd dat hij vertrekt uit het team.</p>
<p>De oprichter van SLERF kondigde de lancering aan van het .slerf Solana-domein.</p>
<p>🔥Crypto-kunstenaar XCOPY deelt aanbevolen FLIES.</p>
<p>🔥CONDOM pre-sale raised bijna 5.000 SOL Rug.</p>
<h2 id="h2-Regelgevende20amp20Macrobeleid959248"><a name="Regelgevende &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevende &amp; Macrobeleid</h2><p>🔥De hoger dan verwachte publicatie van Amerikaanse CPI-gegevens heeft marktvolatiliteit veroorzaakt.</p>
<p>🔥De markt voorspelt dat de Federal Reserve later dit jaar mogelijk de rente zal verlagen en slechts 1-2 keer zal verlagen.</p>
<p>🔥Uniswap ontving een kennisgeving van de Amerikaanse SEC Wells.</p>
<p>🔥Paraguay overweegt het verbod op mining te heroverwegen en overweegt overtollige energie te verkopen aan miners.</p>
<h2 id="h2-Crypto20Marktoverzicht847620"><a name="Crypto Marktoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Marktoverzicht</h2><p>⭐Vorige week is de algehele cryptomarkt nog niet begonnen met herstellen en bevindt zich nog steeds in een licht volatiele aanpassingscyclus. Hoewel de meeste cryptocurrencies aan het einde van het weekend een stijgende trend hebben laten zien, zijn de veranderingen niet significant. Op dit moment lijkt het erop dat de komende belangrijke evenementen in de planning een beperkte invloed zullen hebben op de cryptomarkt, met een grotere invloed op de prestaties van individuele valuta’s. Naarmate de halvering van BTC nadert, fluctueert het in- en uitstroom van ETF’s de laatste tijd en is het zeer waarschijnlijk dat de cryptomarkt in de toekomst zal reageren. In de beginfase wordt het echter nog steeds voornamelijk gekenmerkt door volatiliteit.</p>
<p>⭐️Hoewel de algehele marktsituatie deze week niet goed was, boekten enkele belangrijke valuta’s toch aanzienlijke winsten. De top 100 belangrijkste valuta’s, NEO, CKB, ENA en TON, zagen allemaal winsten van meer dan 40%. Dit hangt nauw samen met de officiële acties erachter. Het algemene drijfeffect van de oververhitte MEME-sector eerder is geleidelijk afgezwakt. Van deze steeg <a href="/price/neo-neo" target="_blank" class="blog_inner_link">NEO</a> wekelijks met 47,8%, en de huidige prijs blijft rond de $21,94. Het hoogtepunt van de wekelijkse prijs ligt rond de $23,5, terwijl het dieptepunt rond de $14,8 ligt tijdens de openingsperiode.<br><img src="https://gimg2.gateimg.com/image/article/17128901511.jpeg" alt=""><br>(Data Met Dank Aan Coinmarketcap)</p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties223858"><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-Bitcoin20BTC154613"><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/17128901882.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>De prijstrend van BTC deze week werd voornamelijk beïnvloed door de grote netto instroom van spot ETF’s en marktverwachtingen na de opening, en er was een opwaartse trend, maar het bleef in principe tussen $69.000 en $72.500. Na het bereiken van een hoogtepunt van een week begon het te fluctueren. Naarmate het weekend naderde, steeg het opnieuw en bleef het schommelen rond $70.000. Het hoogste punt van de wekelijkse prijs is $72.769, terwijl het laagste punt rond $67.470 ligt.</p>
<p>Analyse suggereert dat de prijsprestatie van BTC deze week in lijn is met de conventionele trend, met weinig impact van de handelskant, en waarschijnlijker als gevolg van de schommeling van de conventionele trend onder invloed van nieuwsfactoren. De instroom en uitstroom van ETF-fondsen hebben de afgelopen dagen een fluctuerende trend van grote netto-uitstroom en grote netto-instroom laten zien, en de halvering van BTC is aanstaande. Bovendien, als gevolg van de recente marktprestaties van het BTC L2-spoor, zullen de BTC-prijzen op korte termijn nog steeds een duidelijke ondersteuningskracht hebben, maar het kan moeilijk zijn om een significante opwaartse trend te zien. Momenteel is de schommelingstrend van de munt gedetailleerd, en wordt verwacht dat deze tijdens het weekend boven de $71.000 zal uitkomen, gevolgd door een lichte daling. Er is een grote kans op significante prijsschommelingen in de volgende week.</p>
<p><a href="/price/audius-audio" rel="nofollow noopener noreferrer" target="_blank">Audius</a><img src="https://gimg2.gateimg.com/image/article/17128902273.jpeg" alt=""><br>(Data Met Dank Aan TradingView)</p>
<p>De prijstrend van ETH deze week is vergelijkbaar met die van BTC. Onlangs is de prijs van ETH herhaaldelijk fluctuerend geweest in het bereik van $3.300-$3.600. De trend van deze week wordt nog steeds meer beïnvloed door de markt en toont een regelmatige fluctuatietrend. Het hoogtepunt van de prijs binnen een week ligt rond de $3.730, terwijl het dieptepunt rond de $3.347 ligt in de openingsfase.</p>
<p>Analyse suggereert dat de prijs van ETH deze week geen significante hoogtepunten kent en het Ethereum-ecosysteem de laatste tijd ook in een relatief hete plek is geweest. Dit heeft geleid tot de algehele fluctuatie van de munt op een meer conventionele markt en de prijsprestaties worden meer beïnvloed door marktveranderingen veroorzaakt door andere valuta’s. Naarmate de weekendafsluitingsfase nadert, is er niet veel teken van herstel voor de munt en de waarschijnlijkheid van verdere waardering in de volgende week is laag, met een grote kans op een opleving boven $3.600 tijdens het weekend.</p>
<h2 id="h2-Web320Project20Trend710312"><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 meeste van de negen categorieën projecten vertoonde deze week een neerwaartse trend. Door de impact van fluctuaties in de marktcyclus was er voornamelijk sprake van een neerwaartse trend in verschillende gebieden. Met uitzondering van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> MEME, die bleef stijgen, presteerden andere gebieden slecht. Op dit moment lijkt het erop dat er nog wat tijd nodig is voordat de algehele markt herstelt.<br><img src="https://gimg2.gateimg.com/image/article/1712912544img_v3_029s_19c215c1-ecb1-40a5-9458-c30531711aix.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 visie van de onderzoeker en vormt geen beleggingsaanbevelingen.<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>