Q29pbkdlY2tvOiBSYXBwb3J0byBhbm51YWxlIHN1bGwnaW5kdXN0cmlhIGRlbGxlIGNyaXB0b3ZhbHV0ZSAyMDIy

2023-01-19, 02:07

<p><img src="https://gimg2.gateimg.com/image/article/1674092986SDFX.jpeg" alt=""></p>
<p>Il 2022 si è dimostrato un anno tumultuoso sia per i progetti che per gli utenti nello spazio cripto. L’inverno cripto si è insediato, e il valore totale del mercato cripto attualmente si attesta a $829 miliardi al 1 gennaio 2023, il 64% in meno rispetto all’anno precedente. Mentre i prezzi dei token DeFi e la domanda di NFT rimangono soppressi, i costruttori hanno continuato a sviluppare nuovi e innovativi protocolli, dando origine a nuove tendenze e narrazioni nel corso dell’ultimo anno.</p>
<p>Il nostro completo Rapporto annuale sull’industria cripto del 2022 copre tutto, dal panorama del mercato cripto all’analisi <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e Ethereum, approfondendo l’ecosistema del Finanza Decentralizzata (DeFi) e dei Token Non Fungibili (NFT) e valutando le performance degli Scambi Centralizzati (CEX) e degli Scambi Decentralizzati (DEX).</p>
<p><img src="https://gimg2.gateimg.com/image/article/16740934111.png" alt=""></p>
<h2 id="h2-Principali20820punti20salienti20del20rapporto20annuale20sullindustria20crittografica20202220di20CoinGecko720735"><a name="Principali 8 punti salienti del rapporto annuale sull’industria crittografica 2022 di CoinGecko" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali 8 punti salienti del rapporto annuale sull’industria crittografica 2022 di CoinGecko</h2><p>Ecco un riassunto dello stato delle criptovalute nel 2022:</p>
<p>1.Il mercato delle criptovalute ha continuato a scambiare orizzontalmente dopo il Q2 2022, nell’ambito dei bassi 1 trilione di dollari e al di sotto di esso.</p>
<ol>
<li><p>Le stablecoin perdono 27,3 miliardi di dollari nonostante un aumento della dominanza; nel frattempo USDC e BUSD hanno registrato guadagni nella capitalizzazione di mercato.</p>
</li><li><p>Il contagio FTX ha coinvolto oltre 1 milione di depositanti, creditori e investitori stimati, con altri a venire.</p>
</li><li><p>Gli asset principali hanno avuto una performance scarsa in generale, tranne il Petrolio greggio e il <a href="https://www.gate.io/trade/USD_USDT" target="_blank">Dollaro statunitense</a>. BTC è stato l’attivo con le peggiori prestazioni con una diminuzione del 64,2%.</p>
</li></ol>
<p>Il lock-up di Ether registra una costante crescita trimestrale fino a 15,8 milioni di ETH alla fine dell’anno, trainato dagli aggiornamenti di Ethereum.</p>
<p>6.Il limite di mercato dei token DeFi, esclusi i token stabili e i token avvolti, è crollato del 72,9% e ha visto i derivati superare gli aggregatori di rendimento nella quota di mercato.</p>
<ol>
<li>In mezzo all’inverno degli NFT, la quota di mercato di OpenSea tra le prime 5 piattaforme degli NFT è scesa al 65,4%, ma domina comunque complessivamente.</li></ol>
<p>Il volume degli scambi spot è diminuito del 67,3% a gennaio 2022, registrando il suo più grande calo trimestrale del 21,2% nel Q4.</p>
<h2 id="h2-Dopo20un20Q220brutale20il20mercato20delle20criptovalute20ha20continuato20a20oscillare20lateralmente20nellambito20dei20bassi20120trilioni20e20al20di20sotto162989"><a name="Dopo un Q2 brutale, il mercato delle criptovalute ha continuato a oscillare lateralmente, nell’ambito dei bassi $1 trilioni e al di sotto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dopo un Q2 brutale, il mercato delle criptovalute ha continuato a oscillare lateralmente, nell’ambito dei bassi $1 trilioni e al di sotto</h2><p><img src="https://gimg2.gateimg.com/image/article/16740934312.png" alt=""></p>
<p>Capitalizzazione di Mercato Totale delle Criptovalute &amp; Volume di Trading Spot 2022 - Rapporto Annuale sulle Criptovalute di CoinGecko</p>
<p>In mezzo a condizioni macroeconomiche difficili e una serie di exploit, fallimenti e disastri nell’industria delle criptovalute, l’anno si è concluso con una capitalizzazione di mercato criptata totale di $829 miliardi, che è il 64,1% inferiore ai $2,3 trilioni dell’inizio dell’anno.</p>
<p>Il secondo trimestre del 2022 è stato il periodo più brutale con il più grande calo. Successivamente, i mercati hanno continuato a scivolare lateralmente, fino al crollo di FTX nel novembre 2022.</p>
<p>Il volume medio di trading giornaliero nel trimestre scorso è diminuito del 32,8% da 88,1 miliardi di dollari nel Q3 a 59,2 miliardi di dollari nel Q4. Nel complesso, i volumi di trading giornalieri sono diminuiti costantemente nel corso dell’anno, con una media di 86,0 miliardi di dollari nel 2022.</p>
<p>I movimenti nel mercato delle criptovalute erano strettamente correlati ai movimenti del mercato azionario statunitense, in particolare all’S&amp;P500, durante i primi tre trimestri del 2022. Tuttavia, nel Q4 questa correlazione è diventata negativa poiché le criptovalute hanno subito un calo a causa di FTX, mentre le azioni hanno visto un recupero alla fine dell’anno.</p>
<h2 id="h2-220Le20stablecoin20hanno20perso2027320miliardi20nonostante20il20loro20aumento20di20dominio20nel20frattempo20USDC20e20BUSD20hanno20registrato20guadagni20nella20capitalizzazione20di20mercato793427"><a name="2. Le stablecoin hanno perso $27,3 miliardi nonostante il loro aumento di dominio; nel frattempo USDC e BUSD hanno registrato guadagni nella capitalizzazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Le stablecoin hanno perso $27,3 miliardi nonostante il loro aumento di dominio; nel frattempo USDC e BUSD hanno registrato guadagni nella capitalizzazione di mercato</h2><p><img src="https://gimg2.gateimg.com/image/article/16740934473.png" alt=""></p>
<p>Capitalizzazione di mercato delle stablecoin delle prime 15 stablecoin 2022 - Rapporto annuale CoinGecko sulle criptovalute</p>
<p>Gli investitori cripto si sono rivolti verso asset più sicuri l’anno scorso, con le tre principali stablecoin <a href="https://www.gate.io/trade/USDT_USDT" target="_blank">Tether</a>(USDT), <a href="/price/usd-coin-usdc" target="_blank" class="blog_inner_link">USD Coin</a> (USDC) e <a href="/price/binance-usd-busd" target="_blank" class="blog_inner_link">Binance USD</a> (BUSD) stanno aumentando la loro predominanza nel mercato delle criptovalute. Tuttavia, il mercato delle stablecoin non è stato risparmiato dalle uscite, perdendo complessivamente $27.3 miliardi o il 16.6% entro la fine dell’anno. La maggior parte di questa perdita è stata registrata durante il crollo del TerraUSD (UST) nel maggio 2022. Il settore si è comportato relativamente bene da allora, nonostante il periodico FUD (‘paura, dubbio e incertezza’) di un altro evento di depeggio.</p>
<p>La più grande stablecoin USDT ha visto un calo della capitalizzazione di mercato del 15,5% o 12,2 miliardi di dollari in termini assoluti. Al contrario, USDC e BUSD hanno registrato una crescita simile rispettivamente di 2,3 miliardi di dollari (+5,5%) e 2,1 miliardi di dollari (+14,7%).</p>
<p>I principali stablecoin decentralizzati Dai (DAI) (-43,4%) e <a href="/price/frax-frax" target="_blank" class="blog_inner_link">Frax</a> (FRAX) (-43,9%) hanno registrato perdite percentuali simili, anche se la perdita di $4 miliardi di DAI era quasi 5 volte più grande in termini assoluti.</p>
<p>Al di fuori dei primi 5, Neutrino USD (USDN) è caduto fuori dai primi 15 dopo la depeging avvenuta a novembre, con MAI (MIMATIC) che ne ha preso il posto. <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> (USDD), una stablecoin lanciata a maggio, ora si trova al 8° posto e ha visto il suo market cap oscillare intorno ai 700 miliardi di dollari a metà anno.</p>
<h2 id="h2-320La20contagione20di20FTX20ha20colpito20oltre20120milione20di20depositanti20creditori20e20investitori20stimati2020probabile20che20cadano20altri20domino20nei20prossimi20mesi45196"><a name="3. La contagione di FTX ha colpito oltre 1 milione di depositanti, creditori e investitori stimati; è probabile che cadano altri domino nei prossimi mesi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. La contagione di FTX ha colpito oltre 1 milione di depositanti, creditori e investitori stimati; è probabile che cadano altri domino nei prossimi mesi</h2><p><img src="https://gimg2.gateimg.com/image/article/16740935124.png" alt=""></p>
<p>Elenco non esaustivo di istituzioni colpite dalla contagione FTX 2022 - Rapporto annuale di CoinGecko sulle criptovalute</p>
<p>L’articolo di CoinDesk ha affermato che la maggior parte degli asset di Alameda era in token FTT emessi da FTX. Poco dopo, il CEO di Binance, Changpeng Zhao ‘CZ’, ha annunciato la sua intenzione di scaricare la quota di token FTT di Binance. Questo ha scatenato una corsa alle banche, che ha portato FTX a sospendere i prelievi e successivamente a presentare istanza di fallimento ai sensi del Chapter 11. È emerso in seguito che Alameda era insolvente dopo il crollo di <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> / Luna, e i fondi degli utenti di FTX sono stati utilizzati per sostenere la fallita società di trading.<br>Per citarne alcuni, alcune delle entità gravemente colpite sono:</p>
<ul>
<li><p>La piattaforma di prestito BlockFi aveva $355 milioni su FTX e ulteriori $671 milioni prestati ad Alameda.</p>
</li><li><p>Genesis Global Trading aveva depositi per un valore di $175 milioni inaccessibili su FTX e al momento non è in grado di soddisfare i rimborsi dal suo prodotto di prestito.</p>
</li><li><p>$8 miliardi su Silvergate Bank sono stati ritirati dai depositanti a seguito del crollo di FTX. La banca ha successivamente licenziato il 40% dei suoi dipendenti.</p>
</li></ul>
<p>Sebbene molte aziende e istituzioni siano già crollate, è probabile che molte altre seguiranno l’esempio nel corso del 2023.</p>
<h2 id="h2-420Le20principali20attivit20hanno20avuto20una20scarsa20performance20in20generale20tranne20il20petrolio20greggio20e20il20dollaro20statunitense20il20BTC2020stato20lattivit20con20la20peggiore20performance20con20una20diminuzione20del20642442317"><a name="4. Le principali attività hanno avuto una scarsa performance in generale, tranne il petrolio greggio e il dollaro statunitense; il BTC è stato l’attività con la peggiore performance con una diminuzione del 64,2%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Le principali attività hanno avuto una scarsa performance in generale, tranne il petrolio greggio e il dollaro statunitense; il BTC è stato l’attività con la peggiore performance con una diminuzione del 64,2%.</h2><p><img src="https://gimg2.gateimg.com/image/article/16740937645.png" alt=""></p>
<p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> vs. Principali Asset 2022-Rapporto annuale criptato di CoinGecko</p>
<p>La maggior parte degli asset, come l’oro e il TLT, ha chiuso l’anno in rosso. Delle attività, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>(BTC) è stato il peggiore in termini di rendimento nel 2022, chiudendo l’anno con un calo del 64,2%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16740937406.png" alt=""></p>
<p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Tabella dei rendimenti dei prezzi vs Major Assets 2022-Rapporto annuale su Crypto di CoinGecko</p>
<p>Battere tutti gli asset è il <a href="https://www.gate.io/trade/USD_USDT" target="_blank">Dollaro</a> L’indice (DXY), attribuito alla Federal Reserve per l’aumento dei tassi di interesse fino al 2022, ha registrato la maggior parte dei suoi guadagni persi nel Q4 poiché gli aumenti dei tassi di interesse si sono rallentati; il DXY è sceso del -7,4% trimestralmente (QoQ) e ha visto solo un rendimento del prezzo dell’8,0% anno-to-date.</p>
<p>Il petrolio greggio ha registrato significativi guadagni fino al 63,4% verso la fine del primo trimestre a causa di una domanda in aumento – la rimozione dei blocchi COVID-19 in tutto il mondo è coincisa con una massiccia carenza di offerta causata dalla guerra tra Russia e Ucraina. Tuttavia, simile al DXY, ha restituito la maggior parte dei suoi guadagni ed è terminato l’anno solo 6,4% più alto.</p>
<h2 id="h2-520Il20lockup20di20Ether20registra20una20crescita20costante20fino20a2015820milioni20entro20la20fine20dellanno20trainato20dagli20aggiornamenti20di20Ethereum552751"><a name="5. Il lock-up di Ether registra una crescita costante fino a 15,8 milioni entro la fine dell’anno, trainato dagli aggiornamenti di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5. Il lock-up di Ether registra una crescita costante fino a 15,8 milioni entro la fine dell’anno, trainato dagli aggiornamenti di Ethereum</h2><p><img src="https://gimg2.gateimg.com/image/article/16740937937.png" alt=""></p>
<p>ETH Totalmente Staked in Validatori 2022-Rapporto Annuale Crypto di CoinGecko</p>
<p>Nonostante la flessione del mercato delle criptovalute, l’ether totale scommesso (ETH) ha registrato una costante crescita trimestrale, aumentando del 25% nel Q1, del 17,8% nel Q2, dell’8,2% nel Q3 e del 12,5% nel Q4 2022. L’ETH totale scommesso ha chiuso l’anno a 15,8 milioni di unità, in aumento rispetto agli 8,8 milioni.</p>
<p>Nella prima metà del 2022, la crescita dell’ETH totale scommesso nei validatori può essere attribuita a un sentimento rialzista sull’unione di Ethereum. A seguito di una riuscita unione a metà settembre, la comunità crittografica ha iniziato ad anticipare il prossimo aggiornamento di Shanghai - guidando la sua notevole crescita lo scorso trimestre.</p>
<p>Lido (LDO) continua a dominare, detenendo il 29,4% di tutti gli ETH in staking attraverso i suoi 29 operatori di nodi. Il suo concorrente più vicino, Coinbase, deteneva solo il 12,8% del mercato.</p>
<p>Si prevede che l’aggiornamento di Shanghai di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> venga implementato entro marzo 2023 e consentirà agli stakeholder di prelevare il loro ETH - potrebbe dare luogo a una riorganizzazione della classifica degli stakeholder.</p>
<h2 id="h2-620La20capitalizzazione20di20mercato20dei20token20DeFi2020diminuita20del2072920e20ha20visto20i20derivati20superare20gli20aggregatori20di20rendimento20in20quota20di20mercato711193"><a name="6. La capitalizzazione di mercato dei token DeFi è diminuita del 72,9% e ha visto i derivati superare gli aggregatori di rendimento in quota di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6. La capitalizzazione di mercato dei token DeFi è diminuita del 72,9% e ha visto i derivati superare gli aggregatori di rendimento in quota di mercato</h2><p><img src="https://gimg2.gateimg.com/image/article/16740938438.png" alt=""></p>
<p>Capitalizzazione di Mercato dei Token DeFi 2022-Rapporto Annuale Criptovalute di CoinGecko<br>Rispetto al 2021, la capitalizzazione di mercato della Finanza Decentralizzata (DeFi) è diminuita del 72,9%, con vari token di governance e utilità che hanno perso oltre 48,4 miliardi di dollari di valore. La categoria dello staking liquido ha registrato la diminuzione minore del 25,9% anno su anno, probabilmente a causa della narrazione del merge di Ethereum che si è verificata nel terzo trimestre del 2022.</p>
<p>I protocolli DeFi hanno subito un colpo maggiore rispetto al resto del mercato, a causa delle valutazioni precedentemente gonfiate e dei prelievi di capitale. I protocolli di prestito e gli aggregatori di rendimento sono stati i settori peggiori dell’anno, registrando declini fino al 80,5% e all’85,3% rispettivamente. Protocolli come <a href="/price/convex-finance-cvx" target="_blank" class="blog_inner_link">Convex Finance</a> (CVX) e Alchemix (ALCX) hanno subito cali di prezzo fino al 95,0%.</p>
<p>Nonostante una diminuzione del 65,0% YoY, i derivati hanno mantenuto la loro quota di mercato al 7,9%, permettendo loro di superare gli aggregatori di rendimento - attribuito a un aumento di popolarità delle piattaforme perpétue decentralizzate come <a href="/price/gmx-gmx" target="_blank" class="blog_inner_link">GMX</a> (GMX) e Gains Network (GNS).</p>
<h2 id="h2-720In20mezzo20al20primo20inverno20degli20NFT20la20quota20di20mercato20di20OpenSea2020scesa20al2065420ma20domina20ancora35712"><a name="7. In mezzo al primo inverno degli NFT, la quota di mercato di OpenSea è scesa al 65,4%, ma domina ancora" class="reference-link"></a><span class="header-link octicon octicon-link"></span>7. In mezzo al primo inverno degli NFT, la quota di mercato di OpenSea è scesa al 65,4%, ma domina ancora</h2><p><img src="https://gimg2.gateimg.com/image/article/16740938679.png" alt=""></p>
<p>Top 5 Mercati NFT Volume di Scambio 2022 - Rapporto Annuale Crypto CoinGecko</p>
<p>Il mercato degli NFT è nel suo primo ciclo ribassista - i volumi di trading degli NFT nelle prime 8 catene sono crollati del 93,1% da 13,3 miliardi di dollari nel Q1 a 1,5 miliardi di dollari nel Q4 2022. Parallelamente, le royalties dei creatori di NFT sono diminuite in modo simile del 95%, dall’inizio dell’anno.</p>
<p>In mezzo all’inverno degli NFT, OpenSea* domina ancora con il 65,4% della quota di mercato del volume di scambi di NFT, escludendo gli scambi di lavaggio. Sebbene la loro dominanza sia diminuita del 24,3% da gennaio 2022, la crescita degli NFT di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ha spinto la quota di volume di scambi di Magic Eden al 12,5% entro la fine del 2022.</p>
<p>In ogni caso, OpenSea ha difeso la sua posizione contro i nuovi contendenti del marketplace NFT LooksRare (LOOKS) e X2Y2 (X2Y2), che hanno incentivato gli utenti a scambiare e elencare collezioni popolari sulla loro piattaforma. Invece, gli utenti si sono rivolti al wash trading per guadagnare queste ricompense. Su LooksRare, il 98,5% del volume totale di scambi NFT erano wash trades nel gennaio 2022. Si è poi ridotto al 75,5% nel dicembre 2022, a causa di minori emissioni di ricompensa.</p>
<p>*I volumi di trading di OpenSea includono Ethereum, <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> e Solana</p>
<h2 id="h2-820Il20volume20degli20scambi20spot2020diminuito20del2067320da20gennaio20202220registrando20il20suo20pi20grande20calo20trimestrale20del2021220nel20Q4202022136899"><a name="8. Il volume degli scambi spot è diminuito del 67,3% da gennaio 2022, registrando il suo più grande calo trimestrale del 21,2% nel Q4 2022" class="reference-link"></a><span class="header-link octicon octicon-link"></span>8. Il volume degli scambi spot è diminuito del 67,3% da gennaio 2022, registrando il suo più grande calo trimestrale del 21,2% nel Q4 2022</h2><p><img src="https://gimg2.gateimg.com/image/article/167409388710.png" alt=""></p>
<p>Top 10 Borse di Criptovalute Volume di Trading CEX &amp; DEX 2022 - Rapporto Annuale Crypto di CoinGecko</p>
<p>Il volume degli scambi spot sui primi 10 exchange di criptovalute ha totalizzato 1,5 trilioni di dollari a gennaio, ma è sceso del 67,3% ai minimi di tutto l’anno di 0,46 trilioni di dollari a dicembre, all’indomani del crollo di FTX. Il calo maggiore su base trimestrale si è verificato nell’ultimo trimestre, dove il volume totale degli scambi spot è diminuito del 21,2% da 2,9 trilioni di dollari nel Q3 a 2,3 trilioni di dollari nel Q4 2022.</p>
<p>Nonostante la manifestazione aperta dei rischi centralizzati, il rapporto CEX:DEX è rimasto costantemente alto. Mentre la FUD riguardante l’insolvenza di Binance ha dato una piccola spinta alle DEX nel market share a novembre, alla fine del 2022 i CEX comandano il 92,5% del mercato.</p>
<p>I volumi in diminuzione sono un segno che gli investitori si stanno ritirando ulteriormente dal mercato o lo stanno abbandonando completamente attraverso le offerte di uscita da CEX.</p>
<div class="blog-details-info"><br><div>Disclaimer<br><div>Autore: GoinGecko Team<br><div>Editor: Team del blog di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni dell'autore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Il copyright è riservato da GoinGecko. Si prega di contattarci per rimuovere qualsiasi violazione.<p></p><br></div></div></div></div></div></div>