RGFnZWxpamtzIG5pZXV3cyB8IEFuYWxpc3RlbiB6ZWdnZW4gZGF0IGRlIEJUQy1wcmlqcyAnbW9laWxpamsgdGUgdmVybGFnZW4nIGlzOyBGVFggdmVya29jaHQgJDExLDkgbWlsamFyZCBhYW4gU09MOyBEZSBvcHJpY2h0ZXIgdmFuIEFhdmUga2FuIGRlICdrb3N0ZW5zY2hha2VsYWFyJyBhY3RpdmVyZW4=

2024-04-08, 03:14

<p><img src="https://gimg2.gateimg.com/image/article/17125460568.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Analisten20zeggen20dat20Bitcoin20prijzen20moeilijk20laag20te20houden20zijn20FTX20verkoopt2011920miljard20aan20SOL20De20oprichter20van20Aave20kan20de20kosten20schakelaar20activeren504242"><a name="Crypto Dagelijkse Samenvatting: Analisten zeggen dat Bitcoin prijzen moeilijk laag te houden zijn; FTX verkoopt $11,9 miljard aan SOL; De oprichter van Aave kan de ‘kosten schakelaar’ activeren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Analisten zeggen dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> prijzen moeilijk laag te houden zijn; FTX verkoopt $11,9 miljard aan SOL; De oprichter van <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> kan de ‘kosten schakelaar’ activeren</h2><p>Laten we eerst de handelsactiviteit van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor gingen Grayscale Bitcoin spot ETF (GBTC) fondsen afgelopen vrijdag (5 april) door met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> namelijk $198,9 miljoen; Ondertussen was de instroom van Fidelity Bitcoin spot ETF (FBTC) $83 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $7,4 miljoen en de instroom van iShares Bitcoin spot ETF (IBIT) $308,8 miljoen.</p>
<p>Bitcoin is gedaald van zijn historische hoogtepunt van bijna $74.000, maar qua percentage is de recente correctie relatief mild geweest. Op dit moment wordt er $69.482,01 gerapporteerd.</p>
<p>Volgens on-chain analist Checkmate is dit nog duidelijker dan in historische bullmarkten. Hij wees op een feit uit de gegevens die zijn geüpload vanuit zijn grafieksuite Checkonchain: ondanks grootschalige winstconsolidatie en omgekeerde verkoop op hoge niveaus, zorgden verkopers er alleen voor dat de markt met maximaal 20% daalde.</p>
<p>Deze situatie deed zich slechts één keer voor, medio september vorig jaar, en de daaropvolgende terugval bedroeg niet meer dan 15,8%. “De markt absorbeert binnen de dag honderden miljoenen dollars aan geld van verkopers, terwijl bears nog geen terugval van 20% hebben bereikt.”</p>
<p>Na de ineenstorting van de crypto-beurs FTX, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De prijs van ‘s daalde tot een dieptepunt van ongeveer $10. Echter, de token herstelde zich begin 2024. <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> bereikte een historisch hoog marktwaarde van $81 miljard in midden maart. Volgens bronnen geciteerd door Bloomberg heeft FTX zijn schuld afgelost door ongeveer $1,9 miljard aan SOL te verkopen, wat de cryptobeurs heeft geholpen om zijn ineenstorting te overwinnen.</p>
<p>Deze verkoop omvat ongeveer twee derde van de SOL-activa met een totale waarde van ongeveer $2,6 miljard. De veiling omvat maximaal 30 miljoen SOL’s, elk geprijsd op $64. Deze tokens worden verkocht tegen een gereduceerde prijs omdat ze vergrendeld zijn, wat betekent dat ze wat tijd nodig hebben om te worden verkocht.</p>
<p>Het rapport wees er ook op dat de FTX Estate SOL-verkoop is vertraagd. FTX heeft 41 miljoen vergrendelde SOL’s, met een totale waarde van ongeveer $7,5 miljard. Volgens The Block’s <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana prijs</a> pagina, nadat het een bijna 7% daling in 24 uur had meegemaakt, is de handelsprijs van Solana vanaf 13.00 uur Eastern Time vandaag $174,2.</p>
<p>Het gedecentraliseerde leningplatform <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> kan ‘kostenconversie’ activeren. Volgens de post geplaatst door Marc Zeller, oprichter van Aave Chan Initiative, op het X-platform, kan er binnenkort een stemming worden gehouden om te beslissen of de ‘kostenschakelaar’ moet worden geactiveerd en kosten aan houders moet worden toegewezen.</p>
<p>Zeller wees erop dat de huidige nettowinst van Aave DAO ongeveer $60 miljoen per jaar is. Om de activiteit van het netwerk te verhogen, zal er volgende week een tijdelijke inspectie worden uitgevoerd om de kostenomschakeling te activeren… Hij had eerder het idee geopperd om kosten in rekening te brengen voor Aave-stakers in een ander artikel op het X-platform. ‘De nieuwe versie van de beveiligingsmodule zal aan het governance-team voorstellen om kosten toe te wijzen aan stakers,’ schreef hij op 16 maart.</p>
<p>Als Aave DAO ervoor kiest om kosten te activeren, zullen ze in de voetsporen treden van het gedecentraliseerde stablecoin-protocol. <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>. Ondertussen heeft finance onlangs voor een voorstel gestemd om de kostprijsconversie opnieuw in te voeren. Tegelijkertijd het voorstel voor vergoedingsconversie voor de gedecentraliseerde exchange <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> is in de laatste fase van voorbereiding en wordt naar verwachting medio april gepresenteerd.</p>
<h2 id="h2-Markttrends20De20algehele20markt20fluctueert20naar20boven20en20APT20zal20een20grote20ontgrendeling20ervaren538670"><a name="Markttrends: De algehele markt fluctueert naar boven, en APT zal een grote ontgrendeling ervaren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algehele markt fluctueert naar boven, en APT zal een grote ontgrendeling ervaren</h2><p>Vandaag blijft de BTC-prijs rond de $69.500, en de algehele markt vertoont een volatiele opwaartse trend. Met betrekking tot de macro-economie herstelt de Amerikaanse aandelenmarkt en de markt verwacht dat de kans op renteverlagingen in mei slechts 7% is.</p>
<h3 id="h3-Marktplaats20hotspots325812"><a name="Marktplaats hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktplaats hotspots</h3><p>De BTC-ecosysteemtoken blijft stijgen: tokens in de BTC-ecosysteem, zoals CKB, LEVER, RUNESTONE, enz., blijven aanzienlijke stijgingen zien. Onder hen heeft SEAL, het eerste RGB++asset-protocoltoken van CKB, een verbazingwekkende stijging gezien, met een totale waarde die honderden keren hoger is. Levers hebben ook BTC-cross-chain-bruggen gelanceerd. Met de aankomende halvering van BTC bevorderen mijnwerkers de ontwikkeling van de BTC-ecosysteem om een aanzienlijke inkomensdaling te voorkomen, wat de welvaart van het hele ecosysteem positief bevordert.</p>
<p>De prestaties van oude DeFi-concepttokens zijn sterk: oude DeFi-tokens zoals FARM, ALCX, CREAM en WING hebben ook aanzienlijke stijgingen gezien. De opkomst van ervaren DeFi-tokens betekent dat de unilaterale opwaartse trend tijdelijk kan eindigen en dat de markt een volatiele fase ingaat. Dit kan betekenen dat investeerders op zoek zijn naar nieuwe beleggingsmogelijkheden of winst nemen.</p>
<p>Sleutel die gegevens ontgrendelt voor deze week: Een van de meest betekenisvolle gebeurtenissen van de week is dat <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> Zal 24,84 miljoen APT’s ontgrendelen om 7:59 (UTC) op 12 april, ter waarde van ongeveer $330 miljoen, goed voor 6,23% van de circulerende voorraad. Voor en na het ontgrendelen van een groot aantal tokens kunnen er significante schommelingen zijn in APT-prijzen. Dit evenement kan een aanzienlijke invloed hebben op de prijstrend van APT-tokens en het investeerderssentiment, en vereist nauwlettend toezicht.</p>
<p>Over het algemeen vertoont de crypto-markt momenteel een volatiele opwaartse trend. De sterke prestaties van BTC-ecosysteemtokens hebben veel vitaliteit aan de markt toegevoegd. Beleggers moeten echter waakzaam zijn voor marktfluctuaties die voortvloeien uit belangrijke ontgrendelingsgegevens van deze week om passende handelsstrategieën te ontwikkelen. Tegelijkertijd is het noodzakelijk om aandacht te blijven besteden aan veranderingen in macro-economische factoren, vooral de trend van de Amerikaanse aandelenmarkt en veranderingen in verwachte renteverlagingen, die een aanzienlijke impact kunnen hebben op de crypto-markt.</p>
<h2 id="h2-Macro20Sterke20werkgelegenheidscijfers20brengen20positieve20emoties20de20winsten20van20Wall20Street20geven20de20Aziatische20markten20verwachtingen481867"><a name="Macro: Sterke werkgelegenheidscijfers brengen positieve emoties; de winsten van Wall Street geven de Aziatische markten verwachtingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Sterke werkgelegenheidscijfers brengen positieve emoties; de winsten van Wall Street geven de Aziatische markten verwachtingen</h2><p>Op 5 april meldde Reuters dat de Amerikaanse aandelenmarkt op een tweejarig hoogtepunt staat, met de S&amp;P 500-index die dit jaar met meer dan 9% is gestegen na zijn sterkste prestatie in het eerste kwartaal sinds 2019.</p>
<p>De afgelopen weken hebben tekenen van inflatie de verwachtingen van de Fed voor een renteverlaging dit jaar verlaagd. Vanwege het sterkere dan verwachte werkgelegenheidsrapport van vrijdag, dreef het de markt verder omhoog. Tegelijkertijd hebben enkele grote ondernemingen zoals Nvidia, META en Microsoft een uiteenlopende prestatie laten zien, wat van invloed kan zijn op het sentiment van beleggers.</p>
<p>Volgens gegevens van het Amerikaanse Department of Labor overtrof het aantal nieuwe banen dat in maart door werkgevers werd toegevoegd ruimschoots de verwachtingen, en bleven de lonen gestaag stijgen, wat erop wijst dat de economie op een solide basis eindigde in het eerste kwartaal.</p>
<p>De Dow Jones Industrial Average steeg met 307,06 punten tot 38.904,04 punten, of 0,80%; De S&amp;P 500-index steeg met 57,13 punten tot 5.204,34 punten, of 1,11%; De Nasdaq Composite-index steeg met 199,44 punten tot 16.248,52, of 1,24%. Alle belangrijke sectoren van de S&amp;P 500-index hebben winst geboekt, waarbij de sectoren telecommunicatiediensten, industrie en technologie de grootste winsten laten zien.</p>
<p>De economische gegevens van deze week lieten echter een gemengde trend zien, met meldingen van zwakke dienstverlenende activiteiten en sterke productierapporten, wat leidde tot een daling van de index.</p>
<p>Op de Aziatische markt wordt verwacht dat de Nikkei 225-index in Japan zal herstellen van de 2% daling van afgelopen vrijdag. De index daalde vorige week met 3,4%, de grootste daling sinds december 2022. De dreiging van wisselkoersen en de steun van Tokio voor interventie in de yen zullen de Japanse aandelenmarkt blijven beïnvloeden.</p>
<p>Op maandag kan het positieve sentiment op Wall Street doorzetten naar de Aziatische markt, maar het is onduidelijk of de markt de druk zal voelen. Deze tekenen geven aan dat de aandelenmarkt momenteel in een fase van hoge consolidatie verkeert in plaats van een fase van winstneming.</p>
<p>De Europese Centrale Bank is van plan later deze week een vergadering te houden en naar verwachting stabiele rentetarieven te handhaven. Beleggers geloven over het algemeen dat er bijna geen mogelijkheid is voor een renteverlaging op 11 april, maar hebben volledig rekening gehouden met de mogelijke renteverlaging in juni en de mogelijkheid van nog eens twee tot drie renteverlagingen later dit jaar.</p>
<p>De geopolitieke spanning moet mogelijk tijdelijk worden verminderd en teams die door Israël en Hamas naar Egypte zijn gestuurd, zijn daar om een mogelijke wapenstilstand te onderhandelen voor de Eid al Fitr-vakantie, wat zal helpen de spanning in het Midden-Oosten te verminderen. Vorige week stegen de olieprijzen met meer dan 4% vanwege bezorgdheid over verstoring van de levering.</p>
<p>Met betrekking tot grondstoffen daalde Amerikaanse ruwe olie met 2,32% naar $84,89 per vat, terwijl Brent-ruwe olie met 2,5% daalde naar $88,89 per vat.</p>
<p>De goudprijs daalde met 0,5% tot $2.317,09 per ounce. Vorige week bereikte goud historische hoogtepunten.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</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.<br></em><div><em></em>Gate.io behoudt alle rechten voor 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>