VGVuZGVuemEgZGkgbWVyY2F0b++9nENoYXJsZXMgSG9za2luc29uIHB1bnRhIGFsbCdhY3F1aXN0byBkaSBDb2luRGVzazsgVW5hIGRlbGxlIHF1YXR0cm8gcHJpbmNpcGFsaSBiYW5jaGUgYXVzdHJhbGlhbmUgZW1ldHRlIFN0YWJsZWNvaW4=

2023-01-20, 05:48

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>In un’altra settimana indiscutibilmente rialzista per il mercato delle criptovalute, le candele verdi sono state illuminate tra le prime cento, concedendo guadagni fino al 25% in tutto il mercato. Poiché questo slancio rialzista ha causato un significativo aumento della valutazione in tutto il mercato, il mercato è stato anche accolto con notizie positive riguardo all’adozione.</p>
<p>È emerso questa settimana che National Australia Bank, una delle quattro grandi banche in Australia, ha svelato la propria stablecoin ancorata al dollaro australiano pronta per l’uso da parte di consumatori e istituzioni. Allo stesso modo, Charles Hoskinson CEO del progetto crittografico votato come il più amato nel mondo occidentale, Cardano, ha rivelato i propri piani per potenzialmente acquistare la power house delle notizie blockchain, CoinDesk. Tuttavia, in notizie forse più preoccupanti, il nuovo CEO di FTX ha dichiarato i suoi piani per potenzialmente riavviare lo scambio. Ma considerata l’infamia e le controversie che circondano questo scambio, questa notizia sembra essere avvolta da ansia e paura mentre si verifica il fallout del crollo.</p>
<h2 id="h2-Le20ultime20notizie759235"><a name="Le ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le ultime notizie</h2><h3 id="h3-Charles20Hoskinson20punta20allacquisto20di20CoinDesk602934"><a name="Charles Hoskinson punta all’acquisto di CoinDesk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Charles Hoskinson punta all’acquisto di CoinDesk</h3><p>Charles Hoskinson, il rinomato CEO di Cardano, ha rivelato in una recente trasmissione in diretta di essere interessato all’acquisizione del più grande portale di notizie criptovalutarie al mondo, Coindesk. Dopo aver lamentato di essere stato trattato in modo non equo dai media in passato, Hoskinson aspira a reintrodurre ‘integrità giornalistica’ nelle fonti di notizie blockchain, citando che il suo interesse nei media è ‘più ampio’.</p>
<p>In precedenza, Hoskinson ha suggerito la possibilità di trasformare i pezzi di notizie in token non fungibili (NFT), consentendo così ai lettori di interagire con e possedere un pezzo di notizie e storia. Vedendo questo concetto come ‘davvero interessante’, Hoskinson crede che trasformare questo concetto in realtà potrebbe rendere possibile che ogni storia diventi una propria entità vivente. Fornendo che Hoskinson possa un giorno acquisire CoinDesk, questo concetto potrebbe davvero diventare realtà.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193557001.png" alt="">Charles Hoskinson (Immagine cortesia di UToday)</p>
<h3 id="h3-Il20CEO20attuale20di20FTX20afferma20di20essere20in20esplorazione20per20riavviare20il20mercato434506"><a name="Il CEO attuale di FTX afferma di essere ‘in esplorazione per riavviare il mercato’" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CEO attuale di FTX afferma di essere ‘in esplorazione per riavviare il mercato’</h3><p>Alla luce dello scioglimento di 130 società operanti sotto l’egida di FTX, John Ray è intervenuto come amministratore delegato dell’exchange di criptovalute FTX per avviare le procedure di fallimento. Tuttavia, è emerso che Ray avrebbe creato un task force per cercare di recuperare l’exchange e riavviare FTX. Secondo un rapporto del Wall Street Journal, Ray ha dichiarato che tutto è ‘sul tavolo’ per quanto riguarda il futuro dell’infame exchange.</p>
<p>Dopo aver riferito il 17 gennaio che c’erano stati 5,5 miliardi di dollari di attività liquide nelle sue indagini, con altri 3 milioni di dollari dovuti ai suoi primi 50 creditori, gli attuali dati finanziari di FTX sembrano disastrosi, sollevando così la domanda: riavviare l’exchange vale la pena o è addirittura fattibile?</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193584002.png" alt=""><br>Logo FTX (Immagine Cortesia di FTX Facebook)</p>
<h3 id="h3-Una20delle20Big20Four20banche20australiane20NAB20emette20la20stablecoin20AUDN692040"><a name="Una delle “Big Four” banche australiane, NAB, emette la stablecoin AUDN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Una delle “Big Four” banche australiane, NAB, emette la stablecoin AUDN</h3><p>La National Australia Bank (NAB) è ora pronta a diventare la seconda delle ‘Big Four’ banche dell’Australia a lanciare una stablecoin ancorata al dollaro australiano (supportata 1:1) sulla rete Ethereum. Avendo previsto il suo lancio entro la metà del 2023, la NAB ha dichiarato che lo scopo di questa stablecoin è semplificare le rimesse transfrontaliere e il commercio di crediti di carbonio.</p>
<p>Il Chief Innovation Officer (CIO) della NAB, Howard Silby, ha dichiarato che la decisione di coniare la stabile AUDN è basata sulla convinzione della banca che l’infrastruttura blockchain abbia il potenziale di svolgere un ruolo cruciale nella prossima evoluzione principale del settore finanziario. ‘Crediamo che ci siano elementi della tecnologia blockchain che faranno parte del futuro delle finanze… dal nostro punto di vista, vediamo [blockchain] come il potenziale per offrire risultati finanziari istantanei, trasparenti e inclusivi’, ha dichiarato Silby.<br><img src="https://gimg2.gateimg.com/image/article/1674193603004.png" alt=""><br>Logo della National Australia Bank (Immagine cortesia della Camera di Commercio dell’Australia)</p>
<h2 id="h2-Tendenze20attuali20del20progetto27633"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>Sulla base dei dati forniti da CoinMarketCap, la maggior parte dei progetti con maggiori guadagni della settimana scorsa si sono concentrati sulla generazione di valore e volume costanti attraverso strutture economiche inflazionistiche. Molti di questi progetti cercano di risolvere problemi come la riduzione del marketing e dello sviluppo durante i mercati ribassisti. Di conseguenza, alcuni di questi progetti hanno registrato guadagni superiori al 100% in 24 ore, nonché guadagni di quasi il 500% nella settimana scorsa.</p>
<h2 id="h2-La20tendenza20attuale20del20BTC153811"><a name="La tendenza attuale del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tendenza attuale del BTC</h2><p>Continuando dal momento rialzista visto nella settimana precedente, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ha continuato a salire rapidamente a un ritmo senza precedenti, volando sopra la sua SMA a 7 giorni e rimanendo costantemente al di sopra di questo livello. Dopo aver iniziato la settimana a $18.81k, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> è salito bruscamente il 14 gennaio, spingendosi ben al di sopra della soglia dei 20.000 dollari fino a una media di 20.800 dollari. Questa media si è rapidamente trasformata in un supporto di prezzo durante la metà della settimana, con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> testando la regione di $21k e occasionalmente non raggiungendo l’obiettivo, spingendolo così nella regione superiore di $20.9k. Tuttavia, il 18 gennaio, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> finalmente ha superato questa zona di resistenza e ha raggiunto un massimo settimanale di $21,501.44, prima di vedere un brusco calo verso il livello di prezzo minimo, dal quale si è ripreso ed ora sta scambiando leggermente sopra la soglia dei $21k. Avendo superato di gran lunga quello che si prevedeva essere la prossima importante zona di resistenza, si può solo stabilire che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> testerà ora $21.6k, con questo che funge da nuova resistenza locale.</p>
<p>A seguito di questo movimento positivo, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il MVRV (market value to realised value) di BTC è significativamente aumentato nella scorsa settimana, superando finalmente la soglia di 1. Partendo da 0,954 all’inizio della settimana, l’MVRV di BTC è stato il più alto delle ultime settimane, salendo poi fino a 1,075 il 17. Questo segnala che BTC si è finalmente allontanato dall’indicazione di ‘fondo di mercato’ e si è spostato verso un territorio più stabile, indicando che l’asset si è spostato verso una valutazione più realistica e completamente realizzata.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193628005.png" alt=""><br>Dati settimanali BTC MVRV (dati per gentile concessione di Blockchain.com)</p>
<h2 id="h2-Lo20stato20delle20commissioni20gas20di20ETH971236"><a name="Lo stato delle commissioni gas di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato delle commissioni gas di ETH</h2><p>Al 19 gennaio, c’è stata una diminuzione moderata del volume totale di gas utilizzato durante l’ultima settimana rispetto a quello precedente, con la cifra più bassa raggiunta il 15, pari a 108.296.985.205. La cifra più alta raggiunta questa settimana è stata il 17, pari a 108.533.581.326, mostrando un utilizzo totale simile a quello visto all’inizio del 2023. Nonostante questa piccola variazione nel volume di gas utilizzato, l’attuale volume di gas utilizzato sembra essere in linea con le tendenze mensili attuali.</p>
<p>Di conseguenza, questa settimana i limiti delle gas fee di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> hanno subito un moderato aumento rispetto alla settimana precedente. I limiti bassi del gas erano compresi tra 11 e 117 gwei, i limiti medi erano compresi tra 11 e 339 gwei e i limiti alti erano compresi tra 12 e 407 gwei, dimostrando una grande disparità nelle tariffe del gas nell’ultima settimana.</p>
<p>Nelle ultime 24 ore, i principali ‘Gas Guzzlers’ secondo Etherscan sono stati Seaport 1.1 (con commissioni totali di $346.604,82 o 222,84 ETH), Uniswap: Universal Router (con commissioni totali di $255.898,99 o 164,52 ETH), e XEN Crypto: XENT Token (con commissioni totali di $81.210,65 o 140,03 ETH) - dimostrando così un significativo aumento rispetto alla settimana precedente.</p>
<p>Il costo stimato delle transazioni su piattaforme come OpenSea: Vendita, <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Scambio e USDT: Trasferimento, è stato suggerito essere compreso tra $1,29 e $4,59, secondo Etherscan.</p>
<h2 id="h2-La20situazione20macro20attuale272134"><a name="La situazione macro attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione macro attuale</h2><h3 id="h3-Davos20202320Fa20Luce20Sul20Mercato20Cripto20Attuale322676"><a name="Davos 2023 Fa Luce Sul Mercato Cripto Attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Davos 2023 Fa Luce Sul Mercato Cripto Attuale</h3><p>Davos, l’incontro annuale del World Economic Forum, ha permesso ai leader del settore delle criptovalute e alle autorità di regolamentazione di far luce sull’attuale situazione macro delle criptovalute nell’ultima settimana. Con una presenza più contenuta quest’anno, il numero di aziende blockchain presenti è diminuito rispetto agli anni precedenti, ma artisti del calibro di Casper Labs, <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> Foundation e Circle hanno condotto una serie di eventi e discusso questioni come le valute digitali delle banche centrali (CBDC) e il crollo di FTX. Ai magnati della blockchain si sono uniti numerosi rappresentanti delle Nazioni Unite (ONU) che hanno confermato l’uso delle blockchain all’interno delle filiali delle Nazioni Unite (come Advit Nath del Fondo internazionale per lo sviluppo agricolo che ha dichiarato di utilizzare la blockchain per monitorare i fondi donati su base regionale). Questa graduale integrazione dei regolatori tradizionali e dei magnati della blockchain in un forum così vasto è una testimonianza della crescente collaborazione tra i due e potrebbe segnalare che il futuro della tecnologia e della finanza in generale sarà innegabilmente caratterizzato dalla blockchain al centro.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire555181"><a name="Cosa potrebbe arrivare nella settimana a venire?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa potrebbe arrivare nella settimana a venire?</h2><p>Considerando l’ottimismo diffuso sul mercato e le notizie positive riguardanti l’adozione e la regolamentazione, è altamente probabile che la prossima settimana estenderà ulteriormente questo slancio. In tal modo, vari asset tra i primi cento continueranno a guadagnare slancio e rigenerare la valutazione, trainando ulteriormente le criptovalute fuori dalle trincee e sul campo di battaglia mentre combattono per tornare alla loro antica gloria.</p>
<div class="blog-details-info"><br><div>Autore: Ricercatore di Gate.io:<strong>Matthew Webster-Dowsing</strong><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 venga referenziato Gate.io. In tutti gli altri casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>