QXZhbGFuY2hlIHNpIHN0YSByaXZvbGdlbmRvIGEgUldBIFRyYWNrOiBjb2xsYWJvcmF6aW9uZSBjb24gSlBNb3JnYW4gQ2hhc2UsIGkgdG9rZW4gZGVsbCdlY29zaXN0ZW1hIHNpIGFsemFubyBjb2xsZXR0aXZhbWVudGU=

2023-11-20, 03:20

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Introduzione938761"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il gigante finanziario statunitense JPMorgan collaborerà con l’azienda di gestione degli asset alternativi Apollo Global per lanciare il Progetto Guardian.</p>
<p>Il piano utilizzerà il protocollo cross-chain LayerZero per collegare la piattaforma blockchain Onyx di JPMorgan con la <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Sottorete Evergreen. Dopo l’annuncio di questo contenuto, il prezzo di AVAX, che ha recentemente registrato una buona performance, è aumentato di oltre il 20% nelle ultime 24 ore.</p>
<p>Tutto questo rende difficile non concentrarsi su Avalanche: cosa si nasconde dietro queste opportunità e decisioni?<br><img src="https://gimg2.gateimg.com/image/article/170045022015151700449514_.pic.jpg" alt=""><br>Origine: tradingview</p>
<h2 id="h2-Perdita20di20brillantezza20eccellente20logica20sottostante20volume20silenzioso728145"><a name="Perdita di brillantezza: eccellente logica sottostante, volume silenzioso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perdita di brillantezza: eccellente logica sottostante, volume silenzioso</h2><p>Le parole chiave per <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> sono semplici: alte prestazioni, bassa latenza e scalabilità.</p>
<p>La struttura gerarchica di Avalanche stessa favorisce il miglioramento dell’efficienza delle transazioni e la riduzione dei costi. In parole semplici, P-Chain è responsabile del consenso e della gestione della rete, C-Chain è la piattaforma di hosting per i contratti intelligenti e X-Chain gestisce l’emissione e le transazioni degli asset.</p>
<p>Questo design è naturalmente il più favorevole alla costruzione dell’ecosistema di Defi, ma dopo aver formato questa impressione, Avalanche è stato una volta ostacolato.<br><img src="https://gimg2.gateimg.com/image/article/170045024415161700449528_.pic.jpg" alt=""><br>Fonte: academy.avax.network</p>
<p>Avalanche una volta ha dato l’occhio accattivante concetto di “chiunque può creare e distribuire la propria rete blockchain, rendendoli collegati in modo trasparente,” e vogliono davvero che più creatori individuali si uniscano e siano attivi nella rete, promuovendo così la prosperità di Dapps, ecosistema della comunità, e altri aspetti.</p>
<p>Ma questa visione sembra non essere mai stata molto tranquilla - secondo i dati di aprile di quest’anno, l’ecosistema on-chain di Avalanche è un po’ ‘troppo silenzioso’ e la perdita di applicazioni è più grave rispetto ad altre chain pubbliche, come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, con una corrispondente bassa attività degli utenti; il TVL degli asset crittografici bloccati sulla catena è inferiore a 900 milioni di dollari, significativamente ridotto rispetto al periodo di picco nel 2022.</p>
<p>In un certo senso, Avalanche è molto desideroso dell’innovazione e del mantenimento del “contenuto”, ma le sue prestazioni in questo campo non sono soddisfacenti e non ci sono molte voci della comunità. Anche nell’aggiornamento di quest’anno, non c’è stata una grande tendenza di discussione come <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> quando ci sono state due interruzioni della C-chain.</p>
<p>In risposta a questi, la Fondazione Avalanche ha lanciato il programma NFT, collaborando con piattaforme di esports come TSM, nel tentativo di risvegliare un ecosistema attivo. Il fondatore di Ava Labs, Emin, una volta si è lamentato che ‘troppi L1 stanno plagando gli  degli altri e portando cose che il mercato non ha bisogno’. In mezzo all’incessante emergere di nuove narrazioni e discussioni portate dalle soluzioni L2 e dalle varie prove, Avalanche, che si basa su alte prestazioni, scalabilità e caratteristiche di cross chain, è effettivamente un po’ solitario.<br><img src="https://gimg2.gateimg.com/image/article/170045027315171700449544_.pic_hd.jpg" alt=""><br>Origine: unsplash</p>
<p>Immagina se ogni L1 avesse un’immagine personificata, Avalanche potrebbe sembrare un bullo accademico intelligente e riflessivo, ma a causa della sua tranquillità, raramente esprime le sue opinioni, quindi non raccoglie molti feedback dagli altri quando ha bisogno di attenzione.</p>
<p>Anche se Avalanche potrebbe sembrare un po’ in svantaggio nel cerchio delle monete, dove c’è una forte ricerca di opportunità di profitto a breve termine portate da concetti ed emozioni della comunità, d’altra parte, dopo un test del tempo, Avalanche ha le sue riserve e il suo ritmo unici, quindi siamo lieti di constatare che il campo di casa appartenente ad Avalanche sembra essere arrivato.</p>
<h2 id="h2-Avalanche20e20JP20Morgan20Un20ritmo20di20sviluppo20unico20un20adattamento20testimonianza20da20Defi20a20RWA61775"><a name="Avalanche e JP Morgan: Un ritmo di sviluppo unico, un adattamento testimonianza da Defi a RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avalanche e JP Morgan: Un ritmo di sviluppo unico, un adattamento testimonianza da Defi a RWA</h2><p>Innanzi tutto, chiarire il fatto che l’alleanza di Avalanche con JPMorgan Chase non è stata una collisione improvvisa, ma piuttosto un dispiegamento precoce.</p>
<p>JPMorgan Chase ha lanciato il suo piano blockchain nel 2015 e ha rilasciato Quorum su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> dove la tokenizzazione è sempre stata un’attività importante per l’azienda. Onyx Digital Assets è una piattaforma per la banca per regolare i pagamenti in valuta fiat tokenizzata JPM, lanciata alcuni anni fa e ha elaborato oltre 900 miliardi di dollari in transazioni.</p>
<p>Sebbene questo volume di transazioni sia insignificante per JPMorgan Chase, riflette anche la ricerca in corso dell’istituzione sulle applicazioni blockchain. Il progetto di connessione della subnet tra JPMorgan Chase e Avalanche è stato annunciato a gennaio. Considerando che JPMorgan Chase vuole affrontare questioni come la libertà, la sicurezza, l’efficienza dei pagamenti e la stabilità tra le catene, Avalanche è sicuramente la scelta migliore.<br><img src="https://gimg2.gateimg.com/image/article/170045030915181700449563_.pic_hd.jpg" alt=""><br>Fonte: unsplash</p>
<p>Qui, Avalanche sembra aver gradualmente sbloccato ed amplificato il suo scenario vantaggioso - il campo RWA; Prestazioni elevate, basso costo e alta sicurezza non sono più solo aggettivi, ma piuttosto istituzioni finanziarie tradizionali che vogliono applicare la tecnologia blockchain.</p>
<p>Batti il ferro finché è caldo, portando avanti continuamente l’iterazione tecnologica e il potenziamento dell’ecosistema. Dall’inizio di quest’anno, Avalanche promuove con forza lo sviluppo tecnologico e dell’ecosistema. In termini di tecnologia, tra cui il lancio degli aggiornamenti di Cortina per fornire agli sviluppatori un’esperienza migliore, la proposta di aggiornamenti di Astra per migliorare l’architettura della sottorete su Avalanche e la successiva introduzione di tariffe “pay as you go” in AVAX, la riprogettazione di Cortina 14 per la gestione del set di validatori, ecc. In termini di costruzione dell’ecosistema, Avalanche ha lanciato molteplici piani e strumenti di supporto e ha collaborato con le imprese tradizionali.</p>
<p>La notizia dell’ingresso di gigantesche istituzioni finanziarie, unita agli aggiornamenti tecnologici e al graduale miglioramento della costruzione dell’ecosistema, ha permesso ad AVAX di tornare ad essere una potenziale valuta di punta; La continua espansione della base di utenti andrà ulteriormente a beneficio del prospero ecosistema previsto da Avalanche.</p>
<p>Anche se è solo speculazione - dopo due ottimizzazioni del team quest’anno, Avalanche sembra aver trovato un nuovo modo per superare il collo di bottiglia, suscitando discussioni attraverso uno o due. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> di “fare cose” mirate e tecniche di rilascio come aggiornamenti tecnologici, costruzione di ecosistemi e richiamo della comunità in una catena.<br><img src="https://gimg2.gateimg.com/image/article/170045033615191700449580_.pic.jpg" alt=""><br>Fonte: X @avax</p>
<h2 id="h2-Espansione20della20visione20giganti20finanziari20tradizionali20osservano20il20blockchain414640"><a name="Espansione della visione: giganti finanziari tradizionali osservano il blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Espansione della visione: giganti finanziari tradizionali osservano il blockchain</h2><p>Recentemente, anche Citigroup e T Rowe Price e altri. Come JPMorgan Chase, Citigroup non è un nuovo arrivato nel campo degli asset digitali. Già nel 2015, Citigroup ha iniziato a lavorare su argomenti correlati alla blockchain attraverso il suo Innovation Lab.</p>
<p>Quest’anno, Citigroup ha assunto Ryan Rugg, un esperto senior di blockchain aziendale che in precedenza era un dirigente di alto livello presso IBM e R3, un esperto di blockchain nell’industria bancaria, per guidare il nuovo dipartimento di servizi di token della banca. Il pilota di tokenizzazione della banca si basa su blockchain con autorizzazioni.</p>
<p>Per le industrie bancarie e finanziarie tradizionali, l’utilizzo della blockchain è principalmente limitato alle reti con licenza ed è attratto dalla nozione di risparmio sui costi. Studieranno la roadmap del tokenizzazione, digitalizzando tutto, dai fondi del mercato monetario (MMF) ai grandi, ma illiquidi mercati privati e al settore immobiliare.<br><img src="https://gimg2.gateimg.com/image/article/170045036115201700449597_.pic_hd.jpg" alt=""><br>Fonte: unsplash</p>
<p>Alla fine, il mercato più grande per le RWAs bancarie sarà la blockchain pubblica, che richiede una garanzia diversificata. Sergey Nazarov, co-fondatore di Chainlink, immagina: “Penso che le blockchain pubbliche siano disposte a pagare il premio massimo per una garanzia diversificata. Il rendimento mondiale delle blockchain pubbliche è molto interessante per le banche, in quanto possono trarre grandi vantaggi dalla tokenizzazione bancaria e dagli investimenti negli asset dei loro protocolli, rendendo tali protocolli più flessibili e affidabili.”</p>
<p>Considerando che la recente alta volatilità consecutiva di BTC è iniziata anche con la “voce” di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Sebbene gli ETF superino, potrebbe ancora valere la pena lamentarsi del fatto che Defi e finanza tradizionale non sono realmente in opposizione e potrebbero alla fine fondersi.</p>
<p>Attualmente, Avalanche ha acquisito una comprensione di questo e ha trovato un equilibrio tra il suo ritmo e il mercato.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>