V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgRGUgY3J5cHRvbWFya3QgbWFha3QgZWVuIGFhbnppZW5saWprZSBkYWxpbmcgbWVlOyBEZSBzcG90IGhhbmRlbHN2b2x1bWUgdmFuIENFWCBpbiBtYWFydCBpcyAkMi40OFQ7IFcgaGVlZnQgbW9tZW50ZWVsIGVlbiB0b3RhbGUgbWFya3RrYXBpdGFsaXNhdGllIHZhbiBtZWVyIGRhbiAkMTR

2024-04-04, 22:29

<p><img src="https://gimg2.gateimg.com/image/article/1692587604touyanzhoubao.jpeg" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht467851"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>Deze week vertoonde de cryptomarkt een lichte schommeling gevolgd door een snelle daling, met een relatief grote totale amplitude. Momenteel is het hersteld richting het weekend afsluitingsperiode. De algehele marktwaardegroei is afgenomen in vergelijking met de periode van vorige week, en blijft rond de $2,59 biljoen, en is in 24 uur met 4,65% gestegen. Het marktsentiment is gedaald en blijft rond de 72. De meeste belangrijke mainstream valuta’s hebben deze week een neerwaartse trend laten zien, terwijl een paar valuta’s een opwaartse trend hebben behouden, maar de omvang is relatief klein gebleven. Over het algemeen heeft de cryptomarkt deze week enige zwakte getoond in zijn stijging, en de markt bevindt zich in een periode van snelle aanpassing. Er wordt verwacht dat er dit weekend een algemene herstelronde zal zijn.</p>
<p>Vergeleken met vorige week heeft de totale cryptomarkt een neerwaartse trend laten zien, met relatief kleine schommelingen die tot dinsdag werden gehandhaafd, gevolgd door een snelle, volatiele neerwaartse trend. De top 100 crypto-projecten hebben in een week tijd ongeveer 50% stijging en daling gezien, waarbij de ene kant een aanzienlijke daling laat zien in mainstream valuta’s en de andere kant een aanzienlijke stijging laat zien in enkele nieuwe valuta’s bij hun lancering. De BTC-prijs daalde binnen een week opnieuw onder de $70.000 en staat momenteel rond de $68.845, met een wekelijkse stijging of daling van ongeveer -2,72%. ETH heeft ook een aanzienlijke daling doorgemaakt deze week, met een algehele stijging van ongeveer -5,38%. Momenteel blijft het rond de $3.380 en blijft schommelen.</p>
<p>De best presterende coin op de markt deze week is CORE, die in 7 dagen met 107,89% is gestegen. De munt prijs is momenteel ongeveer $2,47, gerangschikt op de eerste plaats in een week van winsten.</p>
<p>De algehele trend van de cryptomarkt deze week is voornamelijk neerwaarts, maar de daling doet zich voornamelijk voor na het midden van de week. Sommige valuta’s hebben echter nog steeds een tegenopwaartse trend laten zien, en de algehele markt zal naar verwachting een herstel doormaken tijdens het weekend.</p>
<h2 id="h2-Crypto20Markt597166"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥 De cryptomarkt heeft de afgelopen week een aanzienlijke snelle daling meegemaakt en is sindsdien hersteld.</p>
<p>🔥 4.1 Dagelijks 4-uur BTC -1,6%, ETH -2,4%; De top 500 bedrijven met een marktwaarde stijging of daling van ≥ 30%: CORE+56%, TRUMP+41%, GFI+34%, MEW -37%; WIF-prijzen, PENDLE-prijzen, Base TVL, Pendle TVL, ETH-munt-houdende adressen, en spot goudprijzen hebben historische hoogtepunten bereikt; De <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het ecosysteem en de Meme-munten op de Base-keten zijn over het algemeen gestegen.</p>
<p>🔥 Ontgrendeling van tokens met hoge waarde deze week: $65,08 miljoen SUI, $14,51 miljoen GAL, $6 miljoen HFT, $5 miljoen ACA, $1,03 miljoen LQTY, enz.</p>
<p>🔥 SLERF betekent dat gebruikers die meer dan 5 SOLs in de pre-sale sturen, ervoor kunnen kiezen om NFT’s te ontvangen.</p>
<p>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft wederom zijn bezit van 8.888 BTC verhoogd, met een totale positie van meer dan 75.000.</p>
<p>🔥 UniSat: geüpgraded naar v1.2.10, ondersteunt 5-byte BRC20.</p>
<p>🔥 BTC-netwerk 837090 blok miners ontvingen in totaal 8.595 BTC beloningen.</p>
<p>🔥 De oprichter van Ordinals bracht de genesis-rune uit, die werd gehalveerd en nog ongeveer vier jaar werd uitgebracht.</p>
<p>🔥 De CEO van <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> verklaarde dat L3 zal strippen <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> van zijn waarde en zal geen L3 ontwikkelen.</p>
<p>🔥 Kanaaleigenaars met meer dan 1000 abonnees op Telegram kunnen 50% van hun advertentie-inkomsten van het kanaal ontvangen, en opnames zullen binnen enkele weken op Fragment worden gelanceerd.</p>
<p>🔥 De oprichter van <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> aangekondigd dat de volgende versie van <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> zal worden gebouwd op L4.</p>
<p>🔥 De gm.ai Foundation heeft een token-economie voorgesteld, en de hoofdwebsite wordt verwacht te lanceren in de derde week van april.</p>
<p>🔥 Op dag 4.2, 24-uurs BTC -4,5%, ETH -5,2%; De top 500 bedrijven met een marktwaarde toename of afname van ≥ 30%: GHST+52%, XVG+39%; GHST-prijs, PUFF-prijs, JTO-prijs, Fren Pet-prijs en DEX-transactievolume in maart bereikten historische hoogtepunten; Meme-munten op de Zora-keten zijn over het algemeen gestegen.</p>
<p>🔥 Op 1 april had BTC spot ETF een nettouitstroom van $88 miljoen, een nettostroom van ongeveer $40 miljoen en een nettostroom van $114 miljoen.</p>
<p>🔥 Zeus Network zal TGE en token airdrops houden op 4 april.</p>
<p>🔥 Vitalik Buterin heeft een uitleg gegeven voor het vereenvoudigen van het Ethereum-protocol en het verminderen van de belasting van nodes, waarbij hij aangeeft dat L3 de doorvoer niet magisch verder kan verbeteren.</p>
<p>🔥 Blast heeft een puntbonusactiviteit gelanceerd, waarmee het gebruik van specifieke DApps punten kan verhogen.</p>
<p>🔥 Ethena heeft de aanvraag voor airdrop tokens geopend en Milady Maker-houders opgenomen in de airdrop scope. Het tweede seizoen van Sats begint op 2 april.</p>
<p>🔥 De spot handelsvolume van CEX in maart bedroeg $2,48 biljoen, bijna op het niveau van november 2021.</p>
<p>🔥 Memeland: zal de Memenet blockchain lanceren, waarbij MEME als de gas wordt gebruikt.</p>
<p>🔥 Robinhood zal OP lanceren.</p>
<p>🔥 Op 3 april, 24-uurs BTC +0.3%, ETH -0.2%; ENA+45% voor de top 500 bedrijven met een marktwaardevermeerdering of -vermindering van ≥ 30%; BGB-prijs, TRC20-USDT-uitgifte, inkomsten van BTC-mijnwerkers in maart en het aantal gebruikers van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L2 bereikte een historisch hoogtepunt.</p>
<p>🔥 Deze week hebben meer dan 20 projecten of instellingen aangekondigd (gepland) om meer dan $3,1 miljard aan financiering te voltooien.</p>
<p>🔥 De circulerende marktwaarde van ENA is $1.25 miljard, met een totale marktwaarde van $12.18 miljard.</p>
<p>🔥 Ethena heeft een brede discussie en controverse veroorzaakt in de industrie.</p>
<p>🔥 Het TON Meme-project Notcoin zal op 20 april een token NOT uitbrengen.</p>
<p>🔥 Het voorstel om de circulatie van Ethereum te verminderen heeft felle kritiek van de cryptogemeenschap veroorzaakt.</p>
<p>🔥 <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> aangekondigd de integratie van het Blast-netwerk, en v2 LP kan native voordelen ontvangen.</p>
<p>🔥 OpenSea ondersteunt het opzetten en uitvoeren van makerinkomen met behulp van ERC721-C.</p>
<p>🔥 BCH heeft deze keer de halvering van de block reward voltooid.</p>
<p>🔥 4.4 BTC van 24 uur +1.0%, ETH +1.0%; De top 500 bedrijven met een marktwaardeverhoging of -vermindering van ≥ 30%: PANDORA+36%, TRIBE+60%, XVG -31%; ENA prijzen, JTO prijzen en PUFF prijzen hebben historische hoogtepunten bereikt.</p>
<p>🔥 Degen: De browserextensie IDriss ondersteunt DEGEN-tips voor X-gebruikers.</p>
<p>🔥 Slerf heeft de tweede ronde van terugbetaling voor 2200 SOL voltooid.</p>
<p>🔥 Rarible ondersteunt al het gebruik van MFER om te betalen voor Base Chain NFT’s.</p>
<p>🔥 Bobaopa heeft tokenvernietiging ondergaan.</p>
<p>🔥 Crypto-kunstenaar XCOPY deelt aanbevolen FLIES.</p>
<p>🔥 Condom voorsele verhoog nearly 5000 SOL after Rug.</p>
<h2 id="h2-Reguleringsbeleid287765"><a name="Reguleringsbeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reguleringsbeleid</h2><p>🔥 Lugano, Zwitserland stelt inwoners en toeristen in staat om dagelijkse transacties uit te voeren met behulp van cryptocurrency.</p>
<p>🔥 Het is de verwachting dat de Federal Reserve’s Daley en Mester dit jaar drie keer de rente zullen verlagen.</p>
<p>🔥 Het rendement op 5-jarige, 10-jarige en 30-jarige schatkistobligaties van de Verenigde Staten bereikte het hoogste punt van het jaar.</p>
<p>🔥 <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Verschillende staten in de Verenigde Staten hebben interesse in het ontwikkelen van een op <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> gebaseerd stemsysteem.</p>
<p>🔥 De Bank voor Internationale Betalingen en zeven centrale banken zullen tokenisatie testen om grensoverschrijdende betalingen te verbeteren.</p>
<h2 id="h2-Crypto20Markt20Highlights117367"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐ Afgelopen week heeft de algehele cryptomarkt een duidelijke neerwaartse trend doorgemaakt en ondergaat momenteel een snelle schommeling en aanpassing. De meeste cryptocurrencies zijn aan het einde van het weekend in een neerwaartse range terechtgekomen, maar er is een hersteltrend. Naarmate de BTC-halvering nadert, in combinatie met opeenvolgende dagen van grote netto instroom van ETF’s, zal waarschijnlijk opnieuw herstel plaatsvinden in de komende periode.</p>
<p>⭐ Hoewel de marktsituatie deze week is verslechterd, hebben sommige belangrijke valuta’s het goed gedaan. Daaronder heeft CORE een goede opwaartse trend laten zien als gevolg van de dynamiek van het project zelf en de aandacht die in de markt wordt besteed aan de Layer2-track. De prijs is in korte tijd door de $4 heen gebroken, met een wekelijkse stijging van 107,89%. Momenteel blijft de prijs rond de $2,45. De wekelijkse prijs ligt rond de $4,1, en de locatie is rond de $1,18 tijdens de openingsperiode.<br><img src="https://gimg2.gateimg.com/image/article/17122695501.jpg" alt=""><br>(Data met dank aan Coinmarketcap)</p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestatie773890"><a name="BTC &amp; ETH Wekelijkse Prestatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Wekelijkse Prestatie</h2><h3 id="h3-Bitcoin20BTC915467"><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/17122695742.jpg" alt=""><br>(Data Courtesy Of TradingView)</p>
<p>De prijstrend van BTC deze week werd voornamelijk gekenmerkt door aanhoudende lichte schommelingen na de opening, gevolgd door een snelle neerwaartse trend, met duidelijke prijsschommelingen. Bij het naderen van het sluitingstijdstip in het weekend is er een relatief duidelijke opwaartse trend, waarbij een voortdurende fluctuatie van ongeveer $69.000 wordt gehandhaafd. De wekelijkse prijs heeft een dieptepunt van ongeveer $64.500 en een hoogtepunt van ongeveer $71.400.</p>
<p>Analyse suggereert dat de prijsprestaties van BTC deze week sterk zijn beïnvloed door de algemene handelsfluctuaties op de markt. Hoewel ETF-fondsen een snelle en grote opbrengst hebben laten zien, heeft de markt aanzienlijke intraday fluctuaties doorgemaakt. Deze ronde van prijsveranderingen lijkt echter meer beïnvloed te worden door marktverkoopgedrag. Hoewel de algemene trend van de munt in de toekomst meestal wordt gedomineerd door het bovengenoemde gedrag, kunnen vergelijkbare neerwaartse trends zich nog steeds voordoen vóór de halvering van BTC, maar het zou nog steeds kortetermijnfluctuaties moeten laten zien. Op dit moment is de trend van de munt licht hersteld en wordt verwacht dat deze tijdens de weekendafsluitingsfase boven de $70.000 zal terugkeren.</p>
<h3 id="h3-Ether20ETH325158"><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/17122696043.jpg" alt=""><br>(Gegevens met dank aan TradingView)</p>
<p>De prijstrend van ETH deze week heeft een sterke correlatie behouden met BTC, hoewel de recente prijsprestaties van ETH relatief zwak zijn en deze neerwaartse trend van de munt eerder verscheen. Op korte termijn nadert het wekelijkse dieptepunt van de prijs $3.200, met een aanzienlijke daling. Het hoogtepunt van de prijs binnen een week ligt rond $3.640, terwijl het dieptepunt rond $3.209 ligt.</p>
<p>Analyse suggereert dat de prestaties van ETH-muntprijzen deze week blijven volgen de algehele markttrend, met een grotere algehele daling in vergelijking met BTC. Dit is gerelateerd aan de publieke opinie die wordt getriggerd door de dynamische informatie over Ethereum deze week, maar belangrijker nog, ETH zelf mist aanzienlijke steun in de huidige marktcyclus. Naarmate de weekendafsluitingsfase nadert, is de hersteltrend van de munt niet bijzonder duidelijk, en wordt gevreesd dat het wekelijkse hoogtepunt nog steeds boven de $3.600 zal blijven, met een lagere kans op verdere stijging.</p>
<h2 id="h2-Web320Project20Trend625199"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h2><p>Deze week vertoonde de totale marktwaarde van de meeste van de negen categorieën van projecten een neerwaartse trend. Vanwege de invloed van de fluctuaties in de marktcyclus was er voornamelijk een neerwaartse trend in verschillende tracks. Andere tracks presteerden slecht, behalve <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> MEME, dat bleef stijgen. Het lijkt erop dat er nog enige tijd nodig is voordat de algehele markt herstelt.<br><img src="https://gimg2.gateimg.com/image/article/1712292336img_v3_029l_bf9389fa-1660-4579-bbda-8519a4e005ix.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 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 op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>