SG9lIHdvcmR0IGVlbiBjcnlwdG8gYmVhciBtYXJrdCBlZW4gYnVsbCBtYXJrdD8=

2023-01-04, 09:53

<p><img src="https://gimg2.gateimg.com/image/article/1672826155深度分析.jpeg" alt=""></p>
<h2 id="h2-TL20DR238641"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De oorzaken van de huidige crypto-bearmarkt zijn onder andere de invasie van Rusland in Oekraïne, de aanpassing van de rentetarieven in de Verenigde Staten en de ineenstorting van TerraUSD en LUNA.</p>
<p>Gemiddeld duurt een crypto bear market 359 dagen.<br>De 2024 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Het halveringsevenement, een grotere adoptie van cryptocurrencies en andere crypto-ontwikkelingen zullen naar verwachting leiden tot het herstel van de huidige crypto-bearmarkt.</p>
<h2 id="h2-Kennismaking347018"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De aanhoudende crypto beermarkt heeft angst, pijn en onzekerheid veroorzaakt bij investeerders op een schaal die nog nooit eerder is gezien. Het begon allemaal in januari 2022 toen de totale marktkapitalisatie van de crypto daalde van $2 biljoen. Dit resulteerde in scherpe dalingen in de prijzen van… <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en altcoin. Bijvoorbeeld, de prijs van BTC is met meer dan 70% gedaald van zijn hoogste punt van $69.044,77, bereikt in november 2021.</p>
<p>Altcoins werden op een grotere manier beïnvloed dan BTC. Bijvoorbeeld, <a href="https://www.gate.io/trade/ETH_USDT" target="_blank">ETH-prijs</a> is met ongeveer 90% gedaald. De situatie is zelfs nog erger voor andere cryptocurrencies waarvan de waarden met grotere marges zijn gedaald. Al verschillende cryptocurrencies zoals LUNA en FTT zijn tijdens het jaar geïmplodeerd.</p>
<h2 id="h2-We20bevinden20ons20in20een20crypto20bear20markt20We20bevinden20ons20in20een20crypto20bear20markt766886"><a name="We bevinden ons in een crypto bear markt. We bevinden ons in een crypto bear markt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>We bevinden ons in een crypto bear markt. We bevinden ons in een crypto bear markt.</h2><p>Op dit moment zijn veel analisten en investeerders het erover eens dat we ons in een diepe cryptomarkt bevinden, gezien hoe hard de prijzen van de meeste cryptocurrencies zijn gedaald. Er is echter iets unieks aan de huidige bearmarkt. Zowel de aandelenmarkt als de cryptomarkt zitten in deze bearmarkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826246WX20230104-174633@2x.png" alt=""><br>Crypto bearmarkt- Yellowcard</p>
<p>De reden waarom beide markten zich in een bearmarkt bevinden, is hun hoge correlatie die we opmerkten na de COVID-19-pandemie. Bijvoorbeeld <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is voor het grootste deel van 2022 gecorreleerd geweest met de aandelenmarkt. Dit komt doordat veel institutionele beleggers die investeren in de aandelenmarkt ook hun geld hebben geïnvesteerd in de cryptosector.</p>
<p>Als gevolg van deze correlatie tussen de cryptomarkt en de aandelenmarkt worden ze beide beïnvloed door veranderingen in de macro-economische variabelen zoals rentetarieven en inflatie.</p>
<p>Met dit in gedachten is het duidelijk om op te merken dat de prijzen van de meeste aandelen zijn gekelderd sinds het begin van 2022. Zo daalde de waarde van de S &amp; P 500-index met meer dan 21% gedurende het jaar.</p>
<p>De prijzen van Amazon, Google en Elon Musks Tesla daalden respectievelijk met meer dan 39%, 27% en 45%. De belangrijkste oorzaken van deze trend zijn inflatie en onzekerheid veroorzaakt door gebeurtenissen zoals de Russische invasie van Oekraïne. Bovendien hebben investeerders en analisten gedurende het grootste deel van 2022 een wereldwijde recessie voorspeld.</p>
<h2 id="h2-Oorzaken20van20de20huidige20bear20market20in20crypto332314"><a name="Oorzaken van de huidige bear market in crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oorzaken van de huidige bear market in crypto</h2><p>De huidige berenmarkt in cryptovaluta heeft veel oorzaken, zoals de invasie van Rusland in Oekraïne, wat leidde tot een scherpe stijging van de brandstofprijzen. Naarmate de wereldwijde inflatie toenam, begon de Verenigde Staten de rentetarieven te verhogen om het te beteugelen.</p>
<p>Zoals hierboven al aangegeven, heeft de bear run die de traditionele aandelenmarkt heeft beïnvloed ook invloed gehad op de cryptosector. Daarom hebben de verhoging van de rente in de Verenigde Staten veel investeerders doen besluiten om niet te investeren in hoogrisico-activa zoals cryptocurrency. Tot nu toe heeft de Federal Reserve de rente zes keer verhoogd in 2022. De verwachting dat het dit verder zal verhogen in 2023 heeft de bear market verlengd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826430WX20230104-174658@2x.png" alt=""><br>Federal Reserve renteverhogingen - Tradingeconomics</p>
<p>De Federal Reserve heeft in 2022 meerdere malen de rente verhoogd.</p>
<p>Regelgevende instanties zoals de Amerikaanse Securities and Exchange Commission dreigden juridische stappen te ondernemen tegen cryptoprojecten die angst en onzekerheid veroorzaakten. Zo spande het een rechtszaak aan tegen Ripple. In dezelfde periode verbood China <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> mining die veel mijnwerkers dwong om te verhuizen naar andere landen.</p>
<p>De ineenstorting van TerraUSD en LUNA, begin dit jaar, heeft de situatie verergerd, aangezien veel investeerders veel van hun investering hebben verloren. Het had een besmettingseffect en leidde tot de liquidatie van verschillende cryptoprojecten zoals Celsius en Three Arrows Capital. De recente ineenstorting van FTX heeft het wantrouwen van sommige mensen in cryptocurrencies vergroot. Over het algemeen is er weinig vertrouwen in de cryptomarkt.</p>
<h2 id="h2-Hoe20lang20kan20de20crypto20bear20markt20duren618367"><a name="Hoe lang kan de crypto bear markt duren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe lang kan de crypto bear markt duren?</h2><p>Veel investeerders willen weten wanneer de crypto bear markt mogelijk zal eindigen, zodat ze hun investeringen van tevoren kunnen plannen. Het goede nieuws is dat de crypto bear markt op een dag zal eindigen. In de meeste glen duurt het enkele maanden voordat het eindigt. De gemiddelde crypto bear markt duurt ongeveer 359 dagen. Het kan dus ongeveer 38 maanden duren vanaf het dieptepunt tot het recente all-time high.</p>
<p>Als feit duurde de crypto beermarkt van 2012 tot 2015 415 dagen, terwijl die van 2017-2018 365 dagen duurde. Ten slotte duurde de beermarkt van 2019-2020 260 dagen. Daarom geven de lengtes van deze eerdere beermarkten ons een aanwijzing van hoelang het kan duren.</p>
<h2 id="h2-Hoe20hebben20de20grote20cryptobearmarkten20zich20hersteld20Hoe20hebben20de20grote20cryptobearmarkten20zich20hersteld455077"><a name="Hoe hebben de grote crypto-bearmarkten zich hersteld? Hoe hebben de grote crypto-bearmarkten zich hersteld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe hebben de grote crypto-bearmarkten zich hersteld? Hoe hebben de grote crypto-bearmarkten zich hersteld?</h2><p>De oorzaken van de cryptocurrency bear-markten zijn niet hetzelfde, maar er zijn enkele overeenkomsten in hoe ze eindigden.<br>Bear-markt van 2014 tot 2015: Het begon toen de prijs van BTC op 14 januari 2014 daalde van $1.135 naar $175. De belangrijkste oorzaken van deze bear-markt waren de ineenstorting van de Mt. Gox-beurs en de Silk Road-marktplaats. Belangrijke ontwikkelingen in de crypto-sector, zoals de lancering van de Trezor digitale portemonnee, de ICO-boom en het Lightning Whitepaper, leidden tot het herstel van deze crypto bear-markt.</p>
<p>bearmarkt van 2018 tot 2019: De prijs van BTC daalde van $ 19.640 naar $ 3.185 tussen 16 december 2017 en 15 december 2018. Een hack van Coincheck en de verhoging van de rente door de Federal Reserve droegen bij aan deze bearmarkt. Aan de andere kant zorgden de NFT-boom en de intrede van PayPal in de cryptosector voor vertrouwen en momentum in de markt, wat leidde tot het herstel.</p>
<h2 id="h2-Herstel20van20de20cryptomarkt539189"><a name="Herstel van de cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Herstel van de cryptomarkt</h2><p>De crypto bear markt zal zeker herstellen, hoewel het moeilijk is om de exacte datum te bepalen. Dit komt doordat het herstel afhankelijk is van veranderingen in de fundamentele economische omstandigheden. Het is zeer onwaarschijnlijk dat de crypto bear markt in 2022 zal herstellen, gezien het feit dat het jaar ten einde loopt.</p>
<p>In plaats daarvan voorspellen analisten dat de prijs van BTC zal dalen tot tussen $10 000 en $15 000 in het eerste kwartaal van 2023, wanneer het een langdurig dieptepunt bereikt. Om een ​​herstel plaats te laten vinden, moeten er verschillende dingen gebeuren.</p>
<p>Op basis van eerdere bearmarkten zou er een herstel moeten zijn van de totale waarde die vergrendeld is in DeFi, die rond het laagste punt binnen twee jaar ligt. Bovendien zou de totale marktkapitalisatie van crypto moeten stijgen tot meer dan $2 biljoen voor een zinvol herstel. Momenteel ligt het ongeveer 73% onder zijn all-time-high.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826475WX20230104-174719@2x.png" alt=""><br>Totale waarde vergrendeld - Beincrypto</p>
<p>Zoals u ziet in het diagram, is de totale vergrendelde waarde meer dan $41 miljard.</p>
<p>Een crypto-analist bOnchain (@ghoddusifar) gelooft dat een ommekeer alleen kan plaatsvinden wanneer de totale marktkapitalisatie daalt tot de delta cap, die de markt ondersteunt.</p>
<h2 id="h2-Halvering20evenement21830"><a name="Halvering evenement" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Halvering evenement</h2><p>Eerder hebben we erop gewezen dat er grote crypto-gerelateerde gebeurtenissen moeten plaatsvinden als er een herstel van de bearmarkt zal zijn. De volgende <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De halveringsevenement die naar verwachting in 2024 zal plaatsvinden, zal waarschijnlijk de markt in een bullrun duwen. In het verleden steeg de prijs van BTC na het halveringsevenement, wat een positief effect had op de hele crypto-markt. Na het halveringsevenement in 2020 steeg de prijs van BTC naar zijn hoogste niveau ooit.</p>
<h2 id="h2-Cryptoregulering528841"><a name="Cryptoregulering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptoregulering</h2><p>Hoewel het onwaarschijnlijk is dat veel landen in 2023 uitgebreide crypto-regelgeving zullen invoeren, zou dergelijke wetgeving het vertrouwen van investeerders versterken. Dit volgt op de ineenstorting en liquidatie van verschillende gevestigde cryptoprojecten zoals Celsius en FTX. Wat de markt nu nodig heeft om te herstellen is vertrouwen in de sector.</p>
<p>In de Verenigde Staten is de Securities and Exchange Commission degene die het juiste juridische kader kan introduceren om cryptocurrencies te reguleren.</p>
<h2 id="h2-Investeerdersvriendelijk20economisch20beleid191880"><a name="Investeerdersvriendelijk economisch beleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeerdersvriendelijk economisch beleid</h2><p>De invoering van passende economische beleidsmaatregelen zal waarschijnlijk leiden tot het herstel van de berenmarkt. Als bijvoorbeeld de Verenigde Staten stopt met het verhogen van de rente, kan dit de koopkracht van consumenten verhogen.</p>
<h2 id="h2-Conclusie256616"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Er waren verschillende crypto-bear-markten die werden veroorzaakt door verschillende factoren. Enkele van de oorzaken zijn het hacken van beurzen, de instorting van cryptocurrencies en macro-economische variabelen zoals inflatie en rentetarieven. De meeste crypto-bear-markten duren tussen de 260 en 415 dagen. Opmerkelijke ontwikkelingen in de sector zoals de NFT-boom en een grotere adoptie van DeFi-producten kunnen de crypto-bear-markt helpen herstellen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<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 zich alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<p></p><br></div></div></div></div>