Q29tZSBpbCBtZXJjYXRvIGRlbGwnb3JzbyBjcml0dG9ncmFmaWNvIHNpIHRyYXNmb3JtYSBpbiBtZXJjYXRpIHJpYWx6aXN0aT8=

2023-01-04, 09:53
<p><img src="https://gimg2.gateimg.com/image/article/1672826155深度分析.jpeg" alt=""></p>
<h2 id="h2-TL20DR872115"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Le cause dell’attuale mercato orso delle criptovalute includono l’invasione della Russia dell’Ucraina, l’adeguamento dei tassi di interesse negli Stati Uniti e il crollo di TerraUSD e LUNA.</p>
<p>In media, un mercato ribassista delle criptovalute dura 359 giorni.<br>Il 2024 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> L’evento di dimezzamento, una maggiore adozione delle criptovalute e altri sviluppi cripto sono probabilmente destinati a causare il recupero dell’attuale mercato ribassista delle criptovalute.</p>
<h2 id="h2-Introduzione754203"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il continuo bear market delle criptovalute ha indotto paura, dolore e incertezza tra gli investitori su una scala mai vista prima. Tutto è cominciato nel gennaio 2022, quando la capitalizzazione di mercato delle criptovalute è scesa da 2 trilioni di dollari. Ciò ha comportato forti diminuzioni dei prezzi di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> e altcoin. Ad esempio, il prezzo del BTC è sceso di oltre il 70% dal suo massimo storico di $69,044.77, raggiunto nel novembre 2021.</p>
<p>Le Altcoin sono state colpite in modo maggiore rispetto a BTC. Ad esempio, <a href="https://www.gate.io/trade/ETH_USDT" target="_blank">prezzo ETH</a> è diminuito di circa il 90%. La situazione è ancora peggiore per altre criptovalute il cui valore è diminuito di margini più ampi. Già diverse criptovalute come LUNA e FTT sono collassate durante l’anno.</p>
<h2 id="h2-Siamo20in20un20mercato20cripto20orso20Siamo20in20un20mercato20cripto20orso918713"><a name="Siamo in un mercato cripto orso. Siamo in un mercato cripto orso." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Siamo in un mercato cripto orso. Siamo in un mercato cripto orso.</h2><p>A questo punto, molti analisti e investitori concordano sul fatto che ci troviamo in un mercato crittografico profondo, considerando quanto duramente sono caduti i prezzi della maggior parte delle criptovalute. Tuttavia, c’è qualcosa di unico nel mercato ribassista attuale. Sia il mercato azionario che quello crittografico sono in questa fase ribassista.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826246WX20230104-174633@2x.png" alt=""><br>Mercato ribassista delle criptovalute - Yellowcard</p>
<p>Il motivo per cui entrambi i mercati sono in un mercato ribassista è la loro alta correlazione che abbiamo notato dopo la pandemia di COVID-19. Ad esempio, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è stato correlato al mercato azionario per la maggior parte del 2022. Questo perché molti investitori istituzionali che investono in borsa hanno messo i loro fondi anche nel settore crypto.</p>
<p>A causa di questa correlazione tra il mercato delle criptovalute e il mercato azionario, entrambi sono influenzati dai cambiamenti nelle variabili macroeconomiche come i tassi di interesse e l’inflazione.</p>
<p>Tenendo presente ciò, è evidente notare che i prezzi della maggior parte delle azioni sono crollati dall’inizio del 2022. Ad esempio, il valore dell’indice S&amp;P 500 è diminuito di oltre il 21% durante l’anno.</p>
<p>I prezzi di Amazon, Google e Tesla di Elon Musk sono scesi rispettivamente del 39%, 27% e 45%. Le principali cause di questa tendenza includono l’inflazione e l’incertezza causata da eventi come l’invasione russa dell’Ucraina. Inoltre, per la maggior parte del 2022, gli investitori e gli analisti hanno previsto una recessione globale.</p>
<h2 id="h2-Cause20del20attuale20mercato20ribassista20delle20criptovalute149510"><a name="Cause del attuale mercato ribassista delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause del attuale mercato ribassista delle criptovalute</h2><p>Il corrente mercato ribassista delle criptovalute ha molte cause, come l’invasione della Russia in Ucraina, che ha causato un brusco aumento dei prezzi del carburante. Con l’aumento dell’inflazione globale, gli Stati Uniti hanno iniziato ad aumentare i tassi di interesse per frenarla.</p>
<p>Come accennato in precedenza, la corsa degli orsi che ha colpito il mercato azionario tradizionale ha anche influenzato il settore delle criptovalute. Pertanto, l’aumento dei tassi di interesse negli Stati Uniti ha portato molti investitori a evitare di investire in asset ad alto rischio come le criptovalute. Finora, la Federal Reserve ha aumentato i tassi di interesse sei volte nel 2022. L’aspettativa che li aumenterà ulteriormente nel 2023 ha prolungato il mercato degli orsi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826430WX20230104-174658@2x.png" alt=""><br>Aumenti dei tassi di interesse della Federal Reserve - Tradingeconomics</p>
<p>La Federal Reserve ha aumentato i tassi di interesse diverse volte nel 2022.</p>
<p>Le autorità di regolamentazione come la Securities and Exchange Commission degli Stati Uniti minacciavano di intraprendere azioni legali contro i progetti cripto che creavano paura e incertezza. Ad esempio, ha intentato una causa contro Ripple. Durante lo stesso periodo, la Cina ha vietato <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> mining che ha costretto molti minatori a trasferirsi in altri paesi.</p>
<p>Il collasso di TerraUSD e LUNA, all’inizio di quest’anno, ha aggravato la situazione dal momento che molti investitori hanno perso gran parte dei loro investimenti. Ciò ha avuto un effetto contagio e ha portato alla liquidazione di diversi progetti cripto come Celsius e Three Arrows Capital. Il recente collasso di FTX ha aumentato la diffidenza di alcune persone nei confronti delle criptovalute. In generale, c’è poca fiducia nel mercato delle criptovalute.</p>
<h2 id="h2-Quanto20pu20durare20il20mercato20ribassista20delle20criptovalute698215"><a name="Quanto può durare il mercato ribassista delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto può durare il mercato ribassista delle criptovalute?</h2><p>Molti investitori vogliono scoprire quando potrebbe finire il mercato ribassista delle criptovalute in modo da pianificare i loro investimenti in anticipo. La cosa buona è che il mercato ribassista delle criptovalute finirà un giorno. Nella maggior parte dei casi, ci vogliono diversi mesi per finire. Il mercato ribassista medio delle criptovalute dura circa 359 giorni. Quindi potrebbero passare circa 38 mesi dal minimo al suo massimo storico recente.</p>
<p>In realtà, il mercato ribassista delle criptovalute dal 2012 al 2015 è durato 415 giorni, mentre quello del 2017-2018 è durato 365 giorni. Infine, il mercato ribassista del 2019-2020 è durato 260 giorni. Pertanto, le durate di questi precedenti mercati ribassisti ci danno un’idea di quanto possa durare.</p>
<h2 id="h2-Come20si20sono20ripresi20i20principali20mercati20ribassisti20delle20criptovalute20Come20si20sono20ripresi20i20principali20mercati20ribassisti20delle20criptovalute272628"><a name="Come si sono ripresi i principali mercati ribassisti delle criptovalute? Come si sono ripresi i principali mercati ribassisti delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come si sono ripresi i principali mercati ribassisti delle criptovalute? Come si sono ripresi i principali mercati ribassisti delle criptovalute?</h2><p>Le cause dei mercati orsi delle criptovalute non sono le stesse, ma ci sono alcune somiglianze su come sono finiti.<br>Mercato orso dal 2014 al 2015: è iniziato quando il prezzo del BTC è crollato da $1.135 a $175 il 14 gennaio 2014. Le principali cause di questo mercato orso sono state il crollo dello scambio Mt. Gox e il mercato Silk Road. Sviluppi chiave nel settore delle criptovalute come il lancio del portafoglio digitale Trezor, l’esplosione dell’offerta iniziale di monete (ICO) e il Lightning Whitepaper hanno portato alla ripresa di questo mercato orso delle criptovalute.</p>
<p>Mercato orso 2018-2019: Il prezzo del BTC è sceso da $19,640 a $3,185 tra il 16 dicembre 2017 e il 15 dicembre 2018. Un hack di Coincheck e l’aumento del tasso di interesse da parte della Federal Reserve hanno contribuito a questo mercato orso. D’altra parte, il boom degli NFT e l’ingresso di PayPal nel settore delle criptovalute hanno creato fiducia e slancio nel mercato, portando al recupero.</p>
<h2 id="h2-Ripresa20del20mercato20crypto497484"><a name="Ripresa del mercato crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripresa del mercato crypto</h2><p>Il mercato dell’orso crittografico si riprenderà sicuramente, anche se è difficile individuare la data esatta. Questo perché il recupero dipende dai cambiamenti nelle condizioni economiche fondamentali. È molto improbabile che il mercato dell’orso crittografico possa riprendersi nel 2022 considerando che l’anno sta volgendo al termine.</p>
<p>Invece, gli analisti prevedono che il prezzo di BTC scenderà tra i $10.000 e i $15.000 nel primo trimestre del 2023, quando raggiungerà un fondo a lungo termine. Perché si verifichi una ripresa, devono accadere diverse cose.</p>
<p>Sulla base dei precedenti mercati ribassisti, dovrebbe esserci un recupero del valore totale totale bloccato dalla DeFi, che si aggira intorno al punto più basso entro due anni. Inoltre, la capitalizzazione totale del mercato delle criptovalute dovrebbe salire a oltre $ 2 trilioni per realizzare una ripresa significativa. Attualmente, è circa il 73% al di sotto del suo massimo storico.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672826475WX20230104-174719@2x.png" alt=""><br>Valore Totale Bloccato- Beincrypto</p>
<p>Come si nota nel diagramma, il valore totale bloccato è superiore a $41 miliardi.</p>
<p>Un analista crittografico bOnchain (@ghoddusifar) ritiene che un’inversione di tendenza possa verificarsi solo quando la capitalizzazione di mercato totale scende al delta cap, che sostiene il mercato.</p>
<h2 id="h2-Evento20di20dimezzamento381936"><a name="Evento di dimezzamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evento di dimezzamento</h2><p>In precedenza, abbiamo evidenziato la necessità che si verifichino importanti eventi legati alle criptovalute se si vuole che ci sia una ripresa dal mercato ribassista. Il prossimo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> L’evento di dimezzamento previsto per il 2024 è probabile che spinga il mercato in una corsa al rialzo. In passato, il prezzo del BTC ha registrato una forte impennata dopo l’evento di dimezzamento che ha avuto un impatto positivo sull’intero mercato delle criptovalute. Dopo l’evento di dimezzamento del 2020, il prezzo del BTC è salito al suo massimo storico.</p>
<h2 id="h2-Regolamentazione20criptovalute112833"><a name="Regolamentazione criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione criptovalute</h2><p>Sebbene sia improbabile che molti paesi introducano regolamentazioni complete sulle criptovalute nel 2023, tali legislazioni aumenterebbero la fiducia degli investitori. Questo segue il crollo e la liquidazione di diversi progetti di criptovalute consolidati come Celsius e FTX. Ciò di cui il mercato ha bisogno ora per riprendersi è la fiducia nel settore.</p>
<p>Negli Stati Uniti, la Securities and Exchange Commission è l’ente che può introdurre il giusto quadro giuridico per regolare le criptovalute.</p>
<h2 id="h2-Politiche20economiche20favorevoli20agli20investimenti314835"><a name="Politiche economiche favorevoli agli investimenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche economiche favorevoli agli investimenti</h2><p>L’introduzione di politiche economiche adeguate è probabilmente destinata a portare alla ripresa del mercato orso. Ad esempio, se gli Stati Uniti smettono di aumentare i tassi di interesse che possono aumentare il potere d’acquisto dei consumatori.</p>
<h2 id="h2-Conclusione733599"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Ci sono stati diversi mercati orso delle criptovalute causati da vari fattori. Alcune delle cause includono l’hacking degli scambi, il crollo delle criptovalute e variabili macroeconomiche come l’inflazione e i tassi di interesse. La maggior parte dei mercati orso delle criptovalute dura tra i 260 e i 415 giorni. Sviluppi significativi nel settore, come l’esplosione delle NFT e una maggiore adozione dei prodotti DeFi, possono aiutare il mercato orso delle criptovalute a riprendersi.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards