UmFwcG9ydG8gc3VsbGUgcHJvc3BldHRpdmUgZGVsIG1lcmNhdG8gY3JpcHRhdG8gc2VsZXppb25hdGUgZGEgTWVzc2FyaSBwZXIgaWwgMjAyMw==

<p><img src="https://gimg2.gateimg.com/image/article/1672902476深度分析.jpeg" alt=""></p>
<h2 id="h2-Astratto107230"><a name="Astratto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Astratto</h2><p>Nel 2023 dobbiamo “tornare alle criptovalute” dall’ossessione del “Web3”.</p>
<p>La frenesia speculativa è ormai un ricordo del passato, e costruire è il momento giusto.</p>
<p>DeFi, NFT e DAO diventeranno le prossime principali direzioni dell’innovazione.</p>
<p>Il 2023 è un buon momento per concentrarsi sull’allocazione di capitale, e vedremo se ci sarà un punto di svolta nella tendenza agli investimenti.</p>
<p>Di Ryan Selkis<br><a href="https://resources.messari.io/pdf/messari-report-crypto-theses-for-2023.pdf" rel="nofollow noopener noreferrer" target="_blank">Link all’articolo originale</a></p>
<h2 id="h2-Introduzione727709"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>“Web3” è un termine che comprende tutte le criptovalute (come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e stablecoin), i contratti intelligenti (come <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e altre soluzioni Layer 1), le reti di infrastrutture decentralizzate (come video, storage e sensori), i token non fungibili (come l’identità digitale e la proprietà), la finanza decentralizzata (servizi finanziari per lo scambio e il collaterale di asset crittografici), il metaverso (risorse pubbliche digitali costruite in un ambiente simile a un gioco) e le strutture di governance della comunità (organizzazioni autonome decentralizzate).</p>
<p>Da quando siamo passati a Web3, il mercato delle criptovalute è sceso dell’80% e l’intero settore ha subito un ‘massacro’. Ora dobbiamo ‘tornare alle criptovalute’ entro il 2023.</p>
<h2 id="h2-Leuforia20speculativa2020passata20e20ci20sono20meno20turisti367682"><a name="L’euforia speculativa è passata e ci sono meno “turisti”." class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’euforia speculativa è passata e ci sono meno “turisti”.</h2><p>Anche se abbiamo enfatizzato la posizione in cui ci troviamo durante questo ciclo particolare, potremmo affrontare un doloroso mercato orso per diversi anni dopo aver sperimentato un massimo prima della fine del primo trimestre del 2022…</p>
<p>Perché ora la frenesia speculativa è passata.</p>
<p>Molte persone hanno perso soldi nel 2022, e alcune aziende gestite in modo inefficiente sono fallite. Ma molti sopravvissuti sono ben finanziati e concentrati sul prodotto. Quindi ora rimangono solo veri credenti e costruttori a lungo termine -</p>
<p><strong>Ci sono meno giocatori d’azzardo, truffatori e turisti.</strong>.</p>
<p>L’essenza fondamentale delle criptovalute non è cambiata: in questo mondo, queste istituzioni sono raramente considerate capaci e morali (a16z: Come vincere il futuro), ma il mondo delle criptovalute può già fornire sufficiente utilità:</p>
<p><strong>- BTC: può attraversare le frontiere, concedendo alle persone la vera proprietà della ricchezza e la libertà di movimento</strong><br><strong>- Gli sviluppatori di Ethereum e altri L1 possono aggirare il monopolio e la censura delle grandi aziende su di esso</strong><br><strong>- DeFi: Finanza senza fiducia e senza permessi</strong><br><strong>- NFT: Rifiutare le alte commissioni dai mercati dell’arte tradizionale</strong><br><strong>- DAO: struttura organizzativa veramente libera</strong></p>
<p>Come la maggior parte degli altri settori tecnologici, Crypto può essere fantastico, ma può anche essere abusato. Tutto dipende dal prodotto specifico, dallo spirito dei creatori e dalle strategie impiegate.</p>
<h2 id="h2-La20tendenza20alla20crittografia2020inevitabile549166"><a name="La tendenza alla crittografia è inevitabile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tendenza alla crittografia è inevitabile</h2><p>È facile essere ottimisti in un periodo di rialzo, ma si può vedere chi nuota nudo solo quando la marea si ritira. In molti modi, quest’anno è stato un brutto anno, specialmente per i avidi, con le leve, e non etici.</p>
<p>Sotto le macerie c’è una solida base senza precedenti: 10 miliardi di dollari di capitale, afflusso di talenti di livello mondiale, la struttura della popolazione che si è spostata verso i nativi digitali negli ultimi quattro anni e innovazioni in dozzine di strumenti di scalabilità crypto “zero a uno” e strumenti applicativi primitivi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672903095Messari 1.png" alt=""></p>
<p><strong>La crittografia è una tendenza inarrestabile</strong> perché abbiamo compiuto progressi significativi nella costruzione di Bitcoin, stablecoin, calcolo distribuito, scalabilità della blockchain, strumenti primitivi per la finanza decentralizzata (DEX, prestiti, emissione di asset) e strutture di governance.</p>
<p>Siamo stati in un lungo periodo di mercato ribassista nel DeFi per due anni adesso, ancora affronta resistenza tecnica e sfide regolamentari, ma gli elementi fondamentali di base (AMM, prestiti flash, valore controllato dal protocollo, ecc.) saranno preservati. Gli NFT aprono anche la porta per la condivisione o il commercio sicuro di qualsiasi proprietà intellettuale, asset sintetici, beni digitalmente consumabili o token di identità on-chain.</p>
<p>Possono aver iniziato con l’aria immatura, ma come strumento primitivo, come tecnologia, la loro importanza è quasi incommensurabile. Ora abbiamo vere DAO con voto on-chain, autorizzazione e gestione finanziaria della comunità, entità che trascendono i confini, consentendo la rapida formazione e chiusura di comunità online e la gestione collettiva della proprietà.</p>
<h2 id="h2-Sopravvivi20al20lungo20inverno20con20Build238874"><a name="Sopravvivi al lungo inverno con Build" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sopravvivi al lungo inverno con Build</h2><p>Molte persone potrebbero perdere fiducia nel calo dei prezzi degli asset per molti anni, nella forte resistenza politica e normativa e nell’entusiasmo stagnante degli utenti e nella domanda di prodotti.</p>
<p>Oltre a subire perdite finanziarie (o effettive) significative, vedrai anche persone che sperimentano crolli mentali, falliscono a causa di una leva finanziaria eccessiva (o di una scarsa pianificazione fiscale), abbandonano progetti promettenti, diventano fastidiose, frustrate o indifferenti e spesso trascurano il potenziale a lungo termine delle criptovalute.</p>
<p>Ciò che è peggio è che nel prossimo mercato orso o in un incubo regolamentare, non avremo l’atmosfera rialzista per aiutarci a resistere a tutte le protezioni per i consumatori, frodi e abusi, rischi sistemici, ESG (ambiente, sociale e governance aziendale) e attività illegali FUD, i nostri nemici ci getteranno addosso questi problemi.</p>
<p>Nel frattempo,</p>
<p><strong>Il gruppo di investitori al dettaglio diminuirà.</strong> Perché quando si perde il 90% dei propri risparmi e si ha bisogno di ritrovare un vero lavoro, ritrovare la fiducia in se stessi diventa ancora più difficile.</p>
<p>Come trascorrere al meglio un lungo inverno? La risposta è semplice, stimolante e tranquilla: Costruire!</p>
<p>In molti modi, costruire una posizione in un mercato orso è più facile che in un mercato toro, con meno interferenze e una più facile identificazione dell’effettivo adattamento prodotto-mercato senza rumore di token, eliminando i contribuenti più deboli e instabili dal mercato.</p>
<p>Nel 2018, c’erano degli investitori che erano curiosi riguardo alle Crypto, ma molti progetti che avevano raccolto fondi attraverso ICO avevano già sperperato i loro asset detenendo più del 90% di ETH.</p>
<p><strong>Per superare con successo l’inverno, riduci le scommesse a leva, riserva contanti per le emergenze, tieni le monete e aspetta.</strong></p>
<h2 id="h2-Guida20alla20costruzione20dei20mercati20ribassisti693431"><a name="Guida alla costruzione dei mercati ribassisti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Guida alla costruzione dei mercati ribassisti</h2><p>Se il mercato dell’orso è per Build, allora sorge una domanda: cosa dovremmo costruire?</p>
<p>Nel 2015, la risposta era l’infrastruttura circostante Bitcoin, con miliardi di dollari di aziende formate per fornire canali di ingresso e uscita tra la cripto-economia e i sistemi finanziari tradizionali.</p>
<p>Nel 2018, la risposta è stata rappresentata dalle applicazioni decentralizzate (dApp), durante le quali sono state incubate dozzine di importanti progetti DeFi (USDC, Uniswap, Aave), NFT (OpenSea, Punks, ENS) e progetti di infrastrutture decentralizzate (Filecoin, Helium, The Graph) durante il profondo inverno. Anche l’intero ecosistema di Ethereum e le blockchain L1 e L2 sono emersi per soddisfare la domanda di spazio di blocco on-chain.</p>
<p>Guardando lo sviluppo del settore nel 2022, potresti trovare il campo degli unicorni che produce la prossima soluzione:</p>
<p>• Vuoi affrontare i rischi sistemici? Abbiamo bisogno di standard di divulgazione degli investimenti, prove di riserva e infrastrutture di monitoraggio on-chain, nonché della contabilità GAAP della crittografia per distinguere i fondamentali dagli investimenti più stupidi.</p>
<p>• Vuoi risolvere il problema degli hacker? Quest’anno è un disastro per gli hacker on-chain, con progetti di smart contract scadenti, exploit di modelli economici, difetti di governance, problemi di sicurezza critici, attacchi di ingegneria sociale e altro ancora. Una soluzione massiccia ai problemi di sicurezza (utilizzando il monitoraggio dell’intelligenza artificiale, gli interruttori automatici degli algoritmi, ecc.) sarà enorme.</p>
<p>• Vuoi essere competitivo nei mercati finanziari cripto? I mutui in eccesso sono meno allettanti rispetto alla finanza tradizionale. Ma non puoi richiedere un prestito senza sufficiente garanzia senza un rischio significativo di insolvenza…… A meno che tu non possa sfruttare nuovi strumenti meta di identità e reputazione.</p>
<p>• Vuoi assicurarti che Amazon, Google o Apple non chiudano la crittografia? Abbiamo ancora bisogno di una rete hardware decentralizzata scalabile, di app store jailbroken e di mercati dati decentralizzati.</p>
<p>• Puoi anche tenere d’occhio alcune delle più grandi società di venture capital del settore e chiedere loro la loro visione per l’industria. Molti di loro condivideranno i loro pensieri e requisiti per le startup.</p>
<h2 id="h2-Il20mercato20continuer20a20declinare571851"><a name="Il mercato continuerà a declinare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il mercato continuerà a declinare?</h2><p>Gli autisti della crescita dei prezzi degli asset sono “venditori”, ma molti di noi non possono fare a meno di essere come “falene nella luce del fuoco”. Quindi, vuoi continuare a scendere?</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672903219Messari 2.png" alt=""></p>
<p>Bitcoin: Questa fase si è conclusa al minimo, e il prossimo obiettivo è un massimo di $500,000;</p>
<p>Ethereum: In termini tecnologici, il miglior paragone con Ethereum potrebbe essere AWS, Google e Microsoft. Ethereum è un ‘computer’ nel mondo virtuale. Ma assomiglia di più a Visa o JPMorgan. ETH ha un rapporto P/E di 195 volte, e il suo reddito da protocollo si sta riducendo;</p>
<p>Altri L1: Ethereum killers e la capitalizzazione di mercato di Ethereum sono di 57 miliardi: 155 miliardi, con ancora potenziale di crescita;</p>
<p>DeFi: DeFi rappresenta solo lo 0,2% della quota di mercato finanziario globale, con un valore totale bloccato (TVL) nei protocolli DeFi di soli 400 miliardi di dollari, che continuerà a salire;</p>
<p>NFT: Qualsiasi progetto NFT può andare a zero, ma come struttura dati, gli asset NFT varranno alla fine migliaia di miliardi di dollari, attualmente solo su una scala di 8 miliardi di dollari, quindi c’è ancora molto spazio per la crescita. L’apprezzamento piuttosto che la mentalità speculativa potrebbe essere più adatta per investire in NFT;</p>
<p>DePIN: Decentralized Physical Infrastructure Network (DePIN), o Token Incentivi, sarà una delle aree più importanti degli investimenti in criptovalute nel prossimo decennio. Soluzioni di archiviazione come <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> e Arweave, reti wireless distribuite come Helium, e altre reti hardware sono cruciali per la sostenibilità a lungo termine del settore.</p>
<h2 id="h2-Continua20lorso20profondo20o20tocca20il20fondo862132"><a name="Continua l’orso profondo o tocca il fondo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Continua l’orso profondo o tocca il fondo?</h2><p>Finora, tutto il contenuto di questo rapporto presuppone che il mercato ribassista continuerà nel prossimo futuro e che non ci sarà una “ripresa a forma di V” nel mercato delle criptovalute. Questa è una visione piuttosto sicura e conservatrice, ma…</p>
<p>Questo riguarda ancora il livello macro (regolamentativo). Il sentimento attuale del mercato è che vedremo una recessione economica nel 2023, con qualche dibattito sul suo potenziale livello. Il mercato sembra anche fidarsi che la banca centrale continuerà ad attuare politiche monetarie restrittive finché l’inflazione non sarà sotto controllo. Nonostante opinioni contrastanti, alcuni investitori credono ancora che una volta che la recessione economica inizierà veramente, la Federal Reserve è più propensa a cambiare direzione e accettare anni di alta inflazione invece di una crisi depressiva o della valuta di riserva globale.</p>
<p>Se questo è il caso, allora le materie prime fisiche come l’oro e il petrolio avranno una forte performance, e l’oro digitale (BTC) e il petrolio digitale (ETH) potrebbero seguire la stessa strada.</p>
<p><strong>D’altra parte, abbiamo anche alcune potenziali crisi che richiedono attenzione:</strong></p>
<p>◇ Per Bitcoin, i minatori stanno vendendo quasi tutti i loro asset estratti per pagare i costi operativi e il debito, creando una pressione venditrice prevedibile senza segni di attenuazione. Il rimborso dalla bancarotta di Mt.Gox (137.000 BTC) probabilmente sarà distribuito all’inizio del 2023, anche se non avrà un impatto diretto sul mercato spot di Bitcoin. Tuttavia, DCG e Genesis potrebbero essere costretti a vendere fino a $60 milioni di azioni GBTC trimestralmente in un futuro prossimo per alleviare la pressione del debito.</p>
<p>◇ Dopo la fusione di Ethereum, la sua offerta può sopprimere l’inflazione, anche se non è chiaro se l’imposta sulle ricompense dello staking dopo la fusione causerà una enorme pressione venditrice sul mercato per compensare le passività generate dal reddito dello staking. Tuttavia, la pressione venditrice dei minatori è diventata una cosa del passato per Ethereum, ma è difficile prevedere la futura pressione venditrice per Ethereum dopo il passaggio a PoS.</p>
<p>◇ Oltre a Bitcoin ed Ethereum, ci sono anche molti progetti specifici con potenziale per vendite caotiche. Ad esempio, L1 e DeFi hanno un gran numero di asset token che potrebbero essere sbloccati dai fondatori o dagli investitori precoci; vendite forzate delle posizioni detenute dai fondi falliti o del collaterale detenuto dai debitori in difficoltà; token male progettati potrebbero soffrire di una “spirale economica mortale” e così via.</p>
<h2 id="h2-Il20capitale20non20dorme20mai113341"><a name="Il capitale non dorme mai" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il capitale non dorme mai</h2><p>Nel 2021, ci sono state 247 round di investimento in startup di infrastrutture centralizzate, 500 round di investimento in startup di infrastrutture decentralizzate e NFT e 218 round di investimento in startup ‘CeFi’, per un importo totale di finanziamento di 28,5 miliardi di dollari statunitensi.</p>
<p>Nel primo semestre del 2022, ci sono stati 183 investimenti nell’infrastruttura centralizzata, 596 investimenti nell’infrastruttura decentralizzata e negli NFT, e 186 investimenti in CeFi, per un importo totale di finanziamento di 27,4 miliardi di dollari.</p>
<p>Anche se il volume totale degli scambi dell’industria DeFi è diminuito da 348 transazioni nel 2021 a 226 transazioni nella prima metà del 2022, l’ammontare totale del finanziamento ha superato quello dell’intero anno 2021 (1,9 miliardi di dollari USA nella prima metà del 2022, mentre nel 2021 era di 1,7 miliardi di dollari USA).</p>
<p>Tuttavia, il rallentamento economico diventerà realtà nella seconda metà del 2022:</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672903232Messari 3.png" alt=""></p>
<p>Rispetto al primo semestre dell’anno, ci aspettiamo che l’importo degli investimenti diminuisca di oltre il 70% nella seconda metà del 2022, e anche il ritmo complessivo degli investimenti rallenterà. Anche i fondi di riserva per il trading di criptovalute stanno diminuendo.</p>
<p>Entro il 2023, il mercato del rischio per le aziende più mature potrebbe diventare ancora più brutale. Nonostante il mercato ribassista e le sue pressioni, è il momento che le aziende con rating A+ dimostrino i loro solidi fondamentali, e ci aspettiamo di vedere significative riduzioni nel volume degli scambi e nel ritmo di crescita.</p>
<p>Il 2023 potrebbe essere un buon momento per concentrarsi sull’allocazione del capitale e vedremo se ci sarà un punto di svolta nelle tendenze degli investimenti.</p>
<h2 id="h2-Acquisizione20e20fallimento16239"><a name="Acquisizione e fallimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Acquisizione e fallimento</h2><p>Negli ultimi mesi, BlockFi ha presentato istanza di fallimento, Circle si è ritirato da SPAC, Kraken ha tagliato il 30% della sua forza lavoro, Genesis sta affrontando una crisi di liquidità e DCG potrebbe anche essere sull’orlo del fallimento.</p>
<p>C’è pericolo e opportunità. I potenziali fondi di Wall Street stanno ancora facendo la fila per entrare nel mercato crittografico. Fidelity o Blackrock potrebbero piacere a DCG in difficoltà, e JPMorgan potrebbe cogliere l’opportunità di acquisire maliziosamente Coinbase con solo il 5% di diluizione. Se l’istituzionalizzazione arriva davvero, bisogna chiedersi se i ‘barbari’ sono già alle porte e se Wall Street è pronta a ‘prendere lentamente il controllo’ della crittografia.</p>
<p>La recente recessione economica potrebbe essere un ponte e alla fine potrebbe dimostrarsi un ponte di cui Wall Street e le grandi istituzioni hanno bisogno per consolidare e acquisire il mercato delle criptovalute su larga scala.</p>
<h2 id="h2-Conclusione681220"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Nel 2022, il tono del mercato delle criptovalute è quello di costruire e investire, con innovazioni criptografiche basate sul soddisfacimento dei reali bisogni del mercato. Pertanto, sarà difficile che il 2023 sia peggiore. Sempre più fondi esterni stanno ancora facendo la fila per salire a bordo, il che è molto diverso dai precedenti mercati ribassisti. Crediamo che i fondamentali del mercato delle criptovalute siano ancora positivi.</p>
<p>In ogni mercato orso, è il momento di accumulare potere per la prossima corsa al rialzo. Un vero costruttore dovrebbe cogliere l’opportunità e attendere pazientemente come un cacciatore per la loro preda.</p>
<div class="blog-details-info"><br><div>Disclaimer<div>Autore:<strong>Ryan Selkis</strong><div>Traduzione: Team del blog Gate.io<div class="info-tips">*Questo articolo rappresenta le opinioni dell'autore originale e non costituisce alcun consiglio di investimento.<p></p></div></div></div></div></div>