Qml0Y29pbiBpcyBzY2hlcnAgZ2VkYWFsZCwga29tdCBlciBlZW4gZWluZGUgYWFuIGRlemUgcm9uZGUgdmFuIGRlIHN0aWVyZW4/

2023-12-12, 08:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR398919"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>Vanaf 10 uur ‘s ochtends (Peking tijd) op 11 december, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> plotseling daalde het tot zijn maximale daling van bijna 7,5%, met meer dan 110.000 mensen die in 24 uur werden verkocht, met een totaalbedrag van $386 miljoen.</p>
<p>De meeste waarnemers geloven dat de belangrijkste reden voor deze daling winstnemingen en liquidatie van lange hefboomposities kan zijn, die werd veroorzaakt door de overgekochte markt die werd aangedreven door een bullish sentiment.</p>
<p>In de huidige situatie waarin frequente verwachtingen optreden op fundamenteel, technisch en emotioneel vlak, vooral bij derivaten, moeten deelnemers hun positiehefboom beheersen en voorzichtig zijn bij het omgaan met kortetermijnverstoringen.</p>
<h2 id="h2-Introductie170448"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Op 11 december keerde <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> plotseling om en daalde het hard, waarbij verschillende valuta passief hun prijzen verlaagden en koud water gooiden in de huidige oververhitte markt. Laten we eens kijken naar deze duikmarkt.</p>
<h2 id="h2-Markt20Bitcoins20kortetermijnduik20bijna2075577060"><a name="Markt: Bitcoin’s korte-termijnduik bijna 7,5%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt: Bitcoin’s korte-termijnduik bijna 7,5%</h2><p>Volgens de Gate.io-markt daalde Bitcoin plotseling tot een minimum van $40.500 om 10 uur ‘s ochtends op 11 december, met de grootste dagelijkse daling van bijna 7,5%, wat de grootste daling op één dag markeert sinds de huidige opwaartse trend en koud water over de huidige hete markt giet.<img src="https://gimg2.gateimg.com/image/article/17023688661.jpg" alt=""><br>Bron: Gate.io</p>
<p>In de afgelopen maand is Bitcoin over het algemeen in een stabiele opwaartse trend geweest, waarbij tokens in sectoren zoals Inion, Legacy Public Chain, Kunstmatige Intelligentie, GameFi en L2 elkaar afwisselen om te stijgen. De marktenthousiasme blijft stijgen, en de marktpaniek- en hebzuchtindex bereikte eens een historisch hoogtepunt van 74, wat overeenkomt met het hoogste punt dat Bitcoin bereikte in de vorige bullmarkt. We hebben ook verschillende artikelen geschreven om deze populaire tracks en algemene markttrends te analyseren en te verkennen.</p>
<p>Na een plotselinge daling op de markt op maandag werd de lange defensieve linie van Bitcoin herhaaldelijk teruggedrongen en onder de enorme verkoopgolf werd het verleden patroon van deleveraging op de markt gereproduceerd onder de opwinding van de markt. Echter, als gevolg van de daling van Bitcoin kwam ook de algehele marktsituatie plotseling tot stilstand en begon het stadium van herstel en aanpassing.</p>
<p>Volgens Coinglass-gegevens, vanaf 11:00 uur op 11 december, het aantal mensen dat in 24 uur posities heeft verkocht op het hele netwerk, overschreed 110.000, met een totaalbedrag van $386 miljoen verkocht. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> beide daalden met meer dan 4%, Ripple daalde met meer dan 6% en <a href="/price/bitcoin-cash-bch" target="_blank" class="blog_inner_link">Bitcoin cash</a> daalde met meer dan 8%.</p>
<h2 id="h2-Interpretatie20Door20hefboomliquidatie20veroorzaakt20door20een20long20squeeze957986"><a name="Interpretatie: Door hefboomliquidatie veroorzaakt door een long squeeze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interpretatie: Door hefboomliquidatie veroorzaakt door een long squeeze</h2><p>Bij gebrek aan significante nieuws, geloven de meeste waarnemers dat de belangrijke reden voor deze daling kan zijn de lange hefboomruimte die is vrijgegeven door de overgekocht markt met overmatig optimistische sentiment. Eén intuïtief bewijs is dat meerdere on-chain grote accountadressen geliquideerd zijn, waardoor de situatie verergert.</p>
<p>Bijvoorbeeld gelooft Richard Galvin, mede-oprichter van Digital Asset Capital Management, dat ‘de huidige daling lijkt op marktdeleveraging, in plaats van enige fundamentele nieuwsaanleiding.’</p>
<p>“Het is logisch om winstnemingen te zien,” zei Tony Sycamore, een marktanalist bij IG Australia. Hij verwacht sterke ondersteuning van koopjesjagers in het bereik van $37.500 tot $40.000.</p>
<p>Medeoprichter van Reflexity Research, Will Clemente, deelt dit standpunt en stelt in een artikel dat Bitcoin in twee maanden is verdubbeld zonder enige terugval, en het is niet verrassend dat er nu een correctie heeft plaatsgevonden. Een terugval zal de zwakkere kant en de hefboomwerking uit de markt persen, waardoor een meer solide basis wordt gelegd voor de ultieme stijging. De volatiliteit van Bitcoin is een kenmerk, geen fout.<img src="https://gimg2.gateimg.com/image/article/17023689052.jpg" alt=""><br>Bron: Twitter@WClementeIII</p>
<p>Bovendien tweette Michael Saylor, medeoprichter van MicroStrategy, dat deze daling bedoeld is als voorbereiding op een stormloop en gepaard gaat met een Bitcoin-bul.</p>
<p>Analist CredibleCrypto, die bijna 360.000 volgers heeft, is ook optimistisch. Hij gelooft dat deze daling niet onder de $40.000 is gezakt en waarschijnlijk zal resulteren in een V-vormige omkering, waarbij de $60.000 wordt doorbroken.</p>
<p>In feite is het niet moeilijk om te zien uit de analyse van de bekende KOLs hierboven genoemd dat iedereen over het algemeen gelooft dat deze kortetermijndaling slechts een klein intermezzo is in de opwaartse trend van Bitcoin. Nadat de markt de leverage heeft afgebouwd, zal het helpen om de huidige overbought markt te herstellen en op de lange termijn nog steeds positief bullish zijn.</p>
<h2 id="h2-Investering20optimistisch20over20de20markt20op20lange20termijn20maar20het20is20nog20steeds20nodig20om20waakzaam20te20zijn20voor20kortetermijnrisicos822660"><a name="Investering: optimistisch over de markt op lange termijn, maar het is nog steeds nodig om waakzaam te zijn voor kortetermijnrisico’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investering: optimistisch over de markt op lange termijn, maar het is nog steeds nodig om waakzaam te zijn voor kortetermijnrisico’s</h2><p>In feite heeft Bitcoin sinds het begin van dit jaar investeringsenthousiasme aangewakkerd onder deelnemers, gedreven door factoren zoals de goede verwachtingen van de goedkeuring van spot ETF’s in de Verenigde Staten, het opschorten van renteverhogingen door de Federal Reserve en technische oververkocht. De populariteit van BRC20-inieverhalen heeft ook een sterke opwaartse trend geopend.</p>
<p>Specifiek kan de recente kortetermijndaling meer worden toegeschreven aan winstnemingen door sommige kortetermijnspeculanten en normale aanpassingen op de overbought markt.</p>
<p>In feite is de prijscorrectie van Bitcoin, in vergelijking met historische trends sinds het laagste punt van $15468 een jaar geleden, niet opvallend geweest en is ook de rotatie van prijsschommelingen normaal.</p>
<p>Zoals weergegeven in de onderstaande figuur, is de maximale daling van Bitcoin in de recente bullmarkt nog steeds minder dan 25%, en zowel de omvang als de frequentie van de daling zijn veel lager dan in eerdere bullmarkten. Dit lijkt erop te wijzen dat Bitcoin geleidelijk evolueert naar een meer volwassen en stabiele activaklasse.<img src="https://gimg2.gateimg.com/image/article/17023689273.jpeg" alt=""><br>Bron: glassnode</p>
<p>Zoals gebruikelijk neigt de markt de halveringstrend van tevoren op te hypen. In deze ronde heeft de bullmarkt al het 50% terugtrekkingsniveau van de vorige berenmarkt doorbroken en staat hij slechts één stap verwijderd van het sterkste weerstandsniveau van 61,8%. Daarom is het, gezien de belangrijke technische positie en de huidige complexe nieuwsverstoring, niet moeilijk om de lichte scherpe stijging en daling van Bitcoin te verklaren.<img src="https://gimg2.gateimg.com/image/article/17023689394.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Ten slotte moeten we iedereen eraan herinneren dat de cryptomarkt zich nog in een vroeg stadium van ontwikkeling bevindt en een hoog groeipotentieel heeft. Natuurlijk gaat dit ook gepaard met enige volatiliteitsrisico’s. In de huidige situatie waarin frequente verwachtingen optreden op het gebied van fundamentals, technologie en emoties, moeten beleggers hun positiehefboom onder controle houden en voorzichtig zijn bij het omgaan met kortetermijnverstoringen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Herpublicatie van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>