Q29uIEFWQVggYWwgZGVjaW1vIHBvc3RvIGluIHRlcm1pbmkgZGkgY2FwaXRhbGl6emF6aW9uZSBkaSBtZXJjYXRvLCBjb3NhIGd1aWRhIGxhICdyZXN1cnJlemlvbmUnIGRlbGxhIHJldGUgQXZhbGFuY2hlPw==

2023-12-15, 02:21

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR517209"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>In appena due settimane di dicembre, il mercato delle criptovalute ha mostrato un tortuoso cambiamento di volume di informazioni esplosive. All’inizio del mese, BTC si è mantenuto intorno a una posizione chiave di $36k fino a $39k, per poi superare $44k in un colpo solo. Il mercato in rapida crescita ha reso difficile per i nuovi e vecchi giocatori continuare il loro tempo libero, e i fondi hanno affluire.</p>
<p>Tuttavia, la settimana scorsa, BTC ha trainato la maggior parte delle Altcoin mainstream e ha inaspettatamente iniziato un trend di ritracciamento. Non è raro che sia le posizioni lunghe che corte si esauriscano entro pochi giorni. Tuttavia, ci sono anche fattori al rialzo, come AVAX.<br><img src="https://gimg2.gateimg.com/image/article/1702606635img_v3_0265_c1026e7e-d818-4aba-9c63-2a28aa1b87ix.jpg" alt=""><br>Origine: Gate.io</p>
<p>Essendo una catena pubblica consolidata, creare forti tassi di crescita non è facile. In precedenza, era <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, ma ora sembra che <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> prenderà il sopravvento. Abbiamo anche studiato le sue importanti tendenze nel blog di Gate in precedenza, specialmente nel campo delle azioni RWA. Per maggiori dettagli, si prega di fare riferimento a <a href="https://www.gate.io/blog_detail/3453/avalanche-turning-to-rwa-track-collaborating-with-jpmorgan-chase-eco-tokens-collectively-rise" target="_blank">Avalanche che si trasforma in RWA Track: Collaborazione con JPMorgan Chase, i Token dell’Ecosistema Salgono Collettivamente</a></p>
<p>Complessivamente, il valore di mercato di AVAX è aumentato del 340% negli ultimi due mesi, raggiungendo i $14,35 miliardi. Diamo un’occhiata a ciò che ha attirato l’attenzione di tutti su di esso.</p>
<h2 id="h2-Aggiornamenti20tecnologici20e20coinvolgimento20degli20utenti729897"><a name="Aggiornamenti tecnologici e coinvolgimento degli utenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamenti tecnologici e coinvolgimento degli utenti</h2><p>La caratteristica principale di <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> è un framework multi-chain composto da subnet di reti scalabili. La rete principale include P-chain, X-chain e C-chain. La gestione di P-chain è responsabile dei validatori e delle funzionalità a livello di subnet, la gestione di X-chain riguarda i token nativi di Avalanche (rappresentazioni digitali di asset reali) e la popolare C-chain è un’implementazione di. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> macchine virtuali.</p>
<p>Nel frattempo, adotta un meccanismo di consenso speciale, cercando il consenso sollecitando un sottoinsieme di validatori, senza la necessità che tutti i nodi registrino e sincronizzino tutte le transazioni, il che migliora l’efficienza e raggiunge una maggiore capacità; Queste combinazioni garantiscono elevate prestazioni, bassa latenza e scalabilità.</p>
<p>Ma con l’emergere di sempre più nuove narrazioni, queste caratteristiche diventano gradualmente meno prominenti, e unito al fatto che la comunità è stata relativamente inattiva, Avalanche è stata piuttosto lenta l’anno scorso. Per migliorare la consapevolezza diffusa e l’attività della comunità, Ava Labs ha fatto anche molti sforzi.<br><img src="https://gimg2.gateimg.com/image/article/1702606685img_v3_0265_c4d979bf-5181-4176-8b20-8751e1c68dix.jpg" alt=""><br>Sorgente: Indirizzo attivo della catena C di Avalanche</p>
<p>In termini di tecnologia, includendo il lancio di aggiornamenti Cortina per fornire ai developer un’esperienza migliore, proponendo gli aggiornamenti Astra per migliorare l’architettura di subnet su Avalanche e successivamente introducendo tariffe “pay as you go” in AVAX, ridisegnando Cortina 14 per la gestione dei set di validatori, ecc. In termini di costruzione dell’ecosistema, Avalanche ha lanciato numerosi programmi di supporto e strumenti e collaborato con imprese tradizionali.</p>
<p>Oltre a queste promozioni, la Fondazione Avalanche ha anche lanciato Avalanche Vista, destinando fino a $50 milioni per l’acquisto dei suoi asset tokenizzati sulla blockchain e promuovendo il suo ruolo nella finanza on-chain. Questa è senza dubbio la misura più pratica e vantaggiosa per i giocatori per sperimentare.</p>
<p>Di conseguenza, sempre più utenti si sono uniti allo sviluppo e alla governance, e le attività di sviluppo su Avalanche continuano ad aumentare, il che condivide alcune somiglianze con lo sviluppo di Solana; TVL aumenta anche con l’aumento del prezzo.</p>
<h2 id="h2-Ecosistema2020Iscrizione20GameFi20NFT20DeFi26556"><a name="Ecosistema - Iscrizione, GameFi, NFT, DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ecosistema - Iscrizione, GameFi, NFT, DeFi</h2><p>Avalanche ospita un ampio ecosistema composto da dApp e protocolli sulla sua C-chain e sulle sue sottoreti, dove l’ecosistema Avalanche può essere esplorato in modo intuitivo.<br><img src="https://gimg2.gateimg.com/image/article/1702606731img_v3_0265_f3c9eeee-3594-4251-a5e5-0837f2dcb0ix.jpg" alt=""><br>Source: <a href="https://core.app/" rel="nofollow noopener noreferrer" target="_blank">https://core.app/</a></p>
<p>È evidente che l’ecosistema su Avalanche sta prosperando, con prestazioni impressionanti nel suo campo Defi maturo, nuovi NFT supportati, settori del gioco e altro ancora.</p>
<p>In termini di giochi, i publisher di giochi coreani si sono uniti ad Avalanche Arcad 3 per esplorare i giochi <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> attraverso il suo ramo Web3, Intella X. Questa collaborazione è stata annunciata alla conferenza Avalanche House Seoul 2023, con l’obiettivo di potenziare l’industria dei giochi Web3 sfruttando l’esperienza di gioco di Neowiz e le funzionalità Web3 di Avalanche.</p>
<p>Ci sono anche molti progetti di alta qualità attivi nei progetti di giochi per giocatore singolo, come il recentemente popolare gioco FPS 3A SHRAPNEL, che è anche su Avalanche.</p>
<p>In termini di DeFi, Unisawp si estende alla catena C Avalanche e raggiunge l’interoperabilità tra <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e Avalanche attraverso LayerZero, potenziando il suo ecosistema DEX. Si tratta di una potente combinazione che può portare l’enorme volume di trading di <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> e modelli di liquidità centralizzati innovativi in Avalanche.</p>
<p>HyperSpace ha anche lanciato il mercato NFT e la bacheca di lancio su Avalanche, introducendo funzioni di trading e analisi in tempo reale per i collezionisti di NFT, arricchendo l’ecosistema NFT precedentemente mediocre di Avalanche.<br><img src="https://gimg2.gateimg.com/image/article/1702606754img_v3_0265_92a7ab14-355e-44af-84eb-79c1323414ix.jpg" alt=""><br>Fonte: hyperspace.xyz</p>
<p>In termini di cooperazione con la finanza tradizionale, i partner di Avalanche includono ma non si limitano a JPMorgan Chase, Citigroup, ecc., il che naturalmente attira utenti ad alto reddito nel campo della finanza tradizionale. Per quanto riguarda la finanza tradizionale e i campi RWA, se interessati, si prega di fare riferimento all’articolo all’inizio di questo articolo.</p>
<p>Inoltre, a causa dell’attuale tendenza degli asset di iscrizione nel mercato, le catene pubbliche che possono sopportare iscrizioni sono facilmente influenzate dalla FOMO. Avalanche, che ha buone prestazioni di rete e commissioni gas basse, è anche una buona scelta. Il costo di fusione dei token ASC-20 è relativamente basso, il che inietta molta vitalità nella rete per un gran numero di giocatori di iscrizioni.<br><img src="https://gimg2.gateimg.com/image/article/1702606780img_v3_0265_543fa592-8e81-4303-8b37-bc3ea79392ix.jpg" alt=""><br>Origine: DUNE</p>
<h2 id="h2-Conclusion47971"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Si può vedere che le azioni proattive del team di Avalanche, così come la visione di collaborare con le finanze tradizionali e concentrarsi su aree come RWA e GamaFi, sono piuttosto illuminanti. Nel breve termine, hanno attirato la partecipazione di numerosi utenti ad alto reddito e sviluppatori, portando a una crescita sorprendente del valore di mercato e del TVL.</p>
<p>Tuttavia, tutto ciò si basa anche sulla sua origine: un meccanismo di consenso unico, caratteristiche di sottorete ad alta velocità e bassa latenza. Sulla base del suo meccanismo sottostante e dell’ecosistema attualmente prospero, Avalanche può andare avanti, ma come investitori, non dobbiamo essere ciechi e dobbiamo sempre guardare contro i potenziali rischi.<br><img src="https://gimg2.gateimg.com/image/article/1702606809img_v3_0265_2c252ea2-6309-4eab-b674-c0ad9c68cbix.jpg" alt=""><br>Sorgente: Avalanche</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>