RGFnZWxpamtzIG5pZXV3cyB8IE1hcmt0IGZsdWN0dWVlcnQgZW4gZGFhbHQsIGhhbmRlbGFyZW4gd2VkZGVuIG9wIGVlbiByZW50ZXZlcmxhZ2luZyB2YW4gMjUgYmFzaXNwdW50ZW4gZG9vciBkZSBGZWQgaW4gc2VwdGVtYmVy

2024-08-16, 04:26

<p><img src="https://gimg2.gateimg.com/image/article/172378256816.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Marktvolatiliteit20neemt20af20en20kan20een20periode20van20stilte20ingaan927245"><a name="Crypto Dagelijks Overzicht: Marktvolatiliteit neemt af en kan een periode van stilte ingaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Marktvolatiliteit neemt af en kan een periode van stilte ingaan</h2><p>Volgens Farside Investor-gegevens, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $11 miljoen. Onder hen had Fidelity FBTC een nettostroom van $16,2 miljoen, Bitwise’s BITB had een nettostroom van $6,2 miljoen, Grayscale GBTC had een nettostroom van $25 miljoen en Grayscale BTC had een nettostroom van $13,7 miljoen.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s hadden een nettostroom van $39,2 miljoen. Daarvan had BlackRock ETHA een nettostroom van $800.000, Fidelity FETH had een nettostroom van $2,5 miljoen, en Grayscale ETHE had een nettostroom van $42,5 miljoen.</p>
<p><strong>MakerDAO heeft het voorstel goedgekeurd om de omvang van het WBTC-onderpand te verlagen</strong></p>
<p>Eerder heeft MakerDAO op 12 augustus een voorstel ingediend om de omvang van het WBTC-onderpand te verkleinen, dat is gebruikt en geïmplementeerd. Het voorstel zal het WBTC-leenbedrag met ten minste $1,25 miljard verminderen.</p>
<p>BA Labs, een bureau voor cryptorisisanalyse en -beoordeling, verklaarde dat vanwege de aanstaande wijziging in WBTC-bewaring, het integreren van WBTC-onderpand op Maker en SparkLend hogere potentiële risico’s met zich meebrengt. Als Bitgo of andere relevante partijen niet overtuigend kunnen aantonen dat de beveiliging van het bestaande WBTC-onderpandintegratie wordt behouden, overweegt BA Labs verdere aanpassing van parameters om het protocol te beschermen totdat het WBTC-onderpand op Maker en SparkLend volledig is verwijderd.</p>
<p><strong>Vandaag zijn er 36,78 miljoen BLUR vrijgegeven</strong></p>
<p>Vandaag is het ontgrendelingstijd voor de eerste uitgifte van BLUR in januari. Er zijn 36,78 miljoen BLURs ($5,64 miljoen) ontgrendeld en overgeboekt van het BLUR-ontgrendelingscontract naar het 0x0A0 multi-handtekeningenadres 5 uur geleden. Het 0x0A0 multi-handtekeningenadres heeft ook een kleine stortingstest ondergaan met het CEX-stortingsadres, en deze BLURs zullen zoals voorheen worden overgeboekt naar CEX.</p>
<p><strong>Met de opeenvolgende implementatie van PPI en CPI zijn de verwachtingen van marktvolatiliteit aanzienlijk afgenomen</strong></p>
<p>Macro-onderzoeker Adam plaatste op sociale media dat met de opeenvolgende landing van PPI en CPI de verwachtingen van marktvolatiliteit aanzienlijk zijn afgenomen, wat op zijn beurt heeft geleid tot een aanzienlijke daling van de belangrijkste IV-maturiteit. De IV op korte termijn is deze week met meer dan 20% gedaald, terwijl er ook een daling is van ongeveer 5% op middellange tot lange termijn.</p>
<p>De daling van de impliciete volatiliteit IV op de optiemarkt is relatief zeldzaam en institutionele verkopers kunnen veel winst goedmaken in deze fase van daling om de hedgingverliezen te compenseren die veroorzaakt zijn door de enorme schommelingen in de afgelopen maand. Nu is de termijnstructuur teruggekeerd naar een stabiele structuur van ver hoog en dichtbij laag, en de markt kan voor een periode van tijd rustig zijn.</p>
<h2 id="h2-Markttrends20De20markt20fluctueert20en20daalt20en20BTC20nadert20het20bodembereik20voor20aankoop352146"><a name="Markttrends: De markt fluctueert en daalt, en BTC nadert het bodembereik voor aankoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt fluctueert en daalt, en BTC nadert het bodembereik voor aankoop</h2><h3 id="h3-Gangbare20munten842234"><a name="Gangbare munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare munten</h3><p>BTC vertoont een fluctuerende neerwaartse trend. Gisteren bedroeg de instroom van BTC-spot-ETF-fondsen slechts 11 miljoen dollar, wat geen significante steun bood aan de markt. Dit geeft aan dat investeerders een afwachtende houding aannemen ten opzichte van de huidige marktomgeving en verwachten dat de volatiele neerwaartse trend van BTC zal aanhouden.</p>
<p>ETH heeft ook slecht gepresteerd. Gegevens tonen aan dat de uitstroom van ETH-spot ETF-fondsen $39 miljoen heeft bereikt, waardoor de neerwaartse druk op de markt verder wordt verergerd. De neerwaartse trend van ETH is consistent met BTC en de markt ontbeert effectieve ondersteuning.</p>
<p>Altcoins: De Altcoin-markt heeft over het algemeen een aanzienlijke daling meegemaakt en de algehele markt mist hotspots en positieve drijfveren. Het sentiment van investeerders is laag en hun interesse in het investeren in Altcoins is aanzienlijk verzwakt.</p>
<h3 id="h3-Gegevensindicatoren669218"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999 Index: Vandaag staat de AHR999 Index op 0,63, en komt geleidelijk in de buurt van het historische bodemkoopbereik. Deze index geeft aan dat de markt mogelijk een ideale koopmoment nadert.</p>
<p>Angst &amp; Hebzucht Index: De huidige Angst &amp; Hebzucht Index is 27, wat aangeeft dat de marktsentiment nog steeds in een staat van angst verkeert. Het trage marktsentiment wordt verwacht nog enige tijd aan te houden, en investeerders wachten over het algemeen op het opkomen van nieuwe markt hotspots en verhalen om de handelsenthousiasme opnieuw aan te wakkeren.</p>
<h3 id="h3-Markt20Hotspots90507"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>WBTC Trust Crisis: Onlangs heeft de bewaring van WBTC (Wrapped Bitcoin) door een bedrijf gesteund door Justin Sun voor veel controverse in de gemeenschap gezorgd. Als het grootste WBTC-stakingsuitleenplatform heeft MakerDAO het voorstel aangenomen om de omvang van het WBTC-onderpand te verlagen, met een cumulatieve vermindering van $1,25 miljard. Momenteel bedraagt de totale omloop van WBTC meer dan 150.000, met een totale waarde van meer dan $8,8 miljard.</p>
<p>Deze reeks gebeurtenissen heeft een vertrouwenscrisis in WBTC veroorzaakt, die op korte termijn moeilijk op te lossen is. Deze vertrouwenscrisis kan potentiële verkoopdruk op de markt creëren, waardoor de marktvolatiliteit verder wordt verergerd.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindexen20sloten20gezamenlijk20hoger20af20en20een20renteverlaging20in20september20is20vrijwel20een20uitgemaakte20zaak589797"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindexen sloten gezamenlijk hoger af, en een renteverlaging in september is vrijwel een uitgemaakte zaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindexen sloten gezamenlijk hoger af, en een renteverlaging in september is vrijwel een uitgemaakte zaak</h2><p>De drie belangrijkste Amerikaanse aandelenindices stegen allemaal met meer dan 1%, waarbij de S&amp;P 500-index met 1,61% steeg tot 5.543,22 punten; De Dow Jones Industrial Average steeg met 1,39% tot 40.563,06 punten; De Nasdaq-index steeg met 2,34% tot 17.594,50 punten. Het referentiepunt 10-jaars rendement op staatsobligaties bedraagt 3,92%, terwijl het 2-jaars rendement op staatsobligaties, dat het meest gevoelig is voor het Federal Reserve beleidsrente, 4,08% bedraagt.</p>
<p>Onder de populaire Amerikaanse aandelen steeg Apple met 1,35%, steeg Microsoft met 1,00%, steeg Nvidia met 4,05%, steeg Google C met 0,70%, steeg Google A met 0,58%, steeg Amazon met 4,40%, steeg Meta met 2,01%, steeg TSMC met 2,35%, steeg Tesla met 6,34% en steeg AMD met 4,70%.</p>
<p>Volgens CME’s “Federal Reserve Watch” is de kans op een renteverlaging van de Federal Reserve met 25 basispunten in september 74% en de kans op een renteverlaging van 50 basispunten 26%. Met de renteverlaging in september bijna als een uitgemaakte zaak, wordt verwacht dat de discussie tijdens de vergadering van de Federal Reserve in september zal gaan over de omvang van de renteverlaging. Waar de Federal Reserve mee worstelt, is of ze voorzichtig de rente met 25 basispunten moeten verlagen of de rente aanzienlijk met 50 basispunten moeten verlagen. Onlangs heeft teleurstellende werkgelegenheidsgegevens zorgen gewekt op de markt dat de Amerikaanse arbeidsmarkt verslechtert en dat ook de Amerikaanse economie in een recessie terecht zal komen.</p>
<p>Analyse suggereert dat de arbeidsmarkt aanzienlijk moet verslechteren voordat de Federal Reserve de rente met 50 basispunten kan verlagen. Brian Ross, Senior Investment Strategist bij UBS Global Wealth Management, verklaarde dat inflatiedata voldoende zijn voor de Federal Reserve om in september met het verlagen van de rente te beginnen, maar gaf geen reden voor een aanzienlijke renteverlaging. Het antwoord op deze vraag kan afhangen van de volgende gegevens over niet-landbouwloonlijsten.</p>
<h3 id="h3-Conclusie370262"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen, de huidige <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> staat onder aanzienlijke neerwaartse druk. De volatiele neerwaartse trend van BTC en ETH is moeilijk om te keren op korte termijn, en de Altcoin-markt ontbreekt ook effectieve hotspots en ondersteuning. De AHR999-index en de Fear &amp; Greed-index geven allebei een trage marktsentiment aan, waarbij investeerders over het algemeen een afwachtende houding aannemen.</p>
<p>De vertrouwenscrisis van WBTC vergroot de marktonzekerheid verder en kan een negatieve invloed hebben op het algemene marktsentiment. Op korte termijn kan de cryptomarkt mogelijk een volatiele neerwaartse trend blijven vertonen, en investeerders moeten voorzichtig blijven en de marktdynamiek en potentiële risicofactoren nauwlettend in de gaten houden.</p>
<p>In deze marktomgeving wordt het aanbevolen dat beleggers geduldig blijven en wachten op de opkomst van nieuwe markthotspots en positieve signalen om op het juiste moment te opereren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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>