VGVuZGVuemEgZGkgbWVyY2F0byB8IEFEQSBwdW50YSBhICQxIG1lbnRyZSBEamVkIFN0YWJsZWNvaW4gb3R0aWVuZSB1bmEgcXVvdGF6aW9uZTsgQ29pbmJhc2UgbXVsdGF0YSBkaSAkMyw2IG1pbGlvbmkgZGFsbGEgQmFuY2EgQ2VudHJhbGUgT2xhbmRlc2U=

2023-01-27, 08:40

<p><img src="https://gimg2.gateimg.com/image/article/1674200553%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""></p>
<p>La scorsa settimana ha presentato un misto di notizie per il mercato delle criptovalute, avendo aperto su una nota relativamente bearish e coincidendo con il continuo degrado del mercato azionario, il mercato si è rapidamente liberato di questi confini e si è spostato in un territorio più bullish. Avendo rigenerato l’onda bullish della settimana precedente, il mercato delle criptovalute sembra pronto a aumentare ulteriormente. Oltre a questa bullishness, i tori di <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> hanno iniziato ad anticipare il potenziale di un superamento della soglia di 1 dollaro all’avvicinarsi del rilascio della stablecoin Djed, cortesia di COTI.</p>
<p>Inoltre, i tori di BTC prevedono che l’asset potrebbe superare la soglia dei 28k dollari nelle prossime settimane se la formazione del golden cross si realizzerà e ne conseguirà uno slancio rialzista. Tuttavia, dal punto di vista istituzionale, Coinbase rischia di essere multato per oltre 3,3 milioni di dollari dalla Banca Centrale Olandese a causa delle accuse secondo cui l’exchange non ha rispettato le leggi locali.</p>
<h2 id="h2-Ultime20notizie712907"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-Bitcoin2020Gli20occhi2028K20lasciano20gli20orsi20increduli894861"><a name="Bitcoin  Gli occhi $28K lasciano gli orsi increduli" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Gli occhi $28K lasciano gli orsi increduli</h3><p>Negli ultimi due settimane, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è stato testimone di una ondata rialzista che ha rigenerato una sostanziale porzione di valore e l’ha liberata dalle folle della regione $13-19k. Ora sopra la soglia dei $20k, i tori stanno puntando a $28.000 come prossimo tetto di prezzo, anticipando che se l’attuale momentum può essere mantenuto, è possibile che BTC possa raggiungere questi massimi. Dopo aver già superato un ciclo di quattro mesi di orso, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> continua a salire costantemente a nuovi massimi quadrimestrali e ora si scambia a una media di $23.000.</p>
<p>Un analista sotto lo pseudonimo, Thescalpingpro, ha dichiarato che la zona da $23.500 a $24.500 rimane un’area chiave da monitorare, avendo affermato che crede che superare questa area spingerà <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> a $28.100. Con questa che agisce come un’area di resistenza pesante, questa zona chiave potrebbe fungere da soffitto di prezzo a condizione che BTC non riesca a guadagnare sufficiente slancio per spingersi oltre questa zona. Al momento, gli orsi stanno principalmente shortando. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, tuttavia è possibile che i sentimenti rialzisti predominanti possano modificare questa strategia di trading e reintrodurre futures e strategie di trading a lungo termine.</p>
<h3 id="h3-ADA20punta20a20120mentre20Djed20Stablecoin20ottiene20la20quotazione288360"><a name="ADA punta a $1 mentre Djed Stablecoin ottiene la quotazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ADA punta a $1 mentre Djed Stablecoin ottiene la quotazione</h3><p>Questo sentimento rialzista si è esteso anche a progetti come Cardano, che i tori e gli analisti si attendono di avvicinarsi nuovamente a 1 dollaro prima del lancio del loro stablecoin Djed. Destinato ad essere rilasciato la prossima settimana, il stablecoin Djed è progettato per favorire l’espansione e le nuove applicazioni nell’ecosistema Cardano. COTI, una piattaforma ottimizzata per la creazione di monete stabili e prossimo emittente di Djed, ha confermato la pianificazione del suo rilascio per la prossima settimana e ha sottolineato i sostanziali sviluppi tecnologici presenti nella sua infrastruttura.</p>
<p>Il team COTI ha anche notato che uno dei principali progressi tecnologici utilizzati per la stablecoin Djed include un processo di indicizzazione della catena, che hanno dichiarato richiederà 14 giorni per essere completato prima del lancio di Djed. La sincronizzazione dell’indice della catena denota un processo finalizzato a garantire che tutti i nodi in una rete siano aggiornati su questioni come le transazioni e i blocchi per garantire la salute e la sicurezza della rete.</p>
<h3 id="h3-Coinbase20multata20di203620milioni20di20dollari20dalla20Banca20Centrale20Olandese301055"><a name="Coinbase multata di 3,6 milioni di dollari dalla Banca Centrale Olandese" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coinbase multata di 3,6 milioni di dollari dalla Banca Centrale Olandese</h3><p>Coinbase è ufficialmente stata multata dalla Banca Centrale Olandese. Ciò avviene alla luce del fatto che il gigante dello scambio di criptovalute non è riuscito a conformarsi alla legislazione locale durante novembre 2020 e agosto 2022. La Banca Centrale Olandese avrebbe preso in considerazione il fatto che la piattaforma è uno dei principali fornitori nella regione e ha un ‘numero significativo di clienti sul suolo locale’. Questa notizia esacerba ulteriormente la recente pressione negativa che circonda lo scambio, con una causa riguardante sfruttamenti e rimozione di fondi degli utenti in corso in America.</p>
<p>Inoltre, Coinbase ha confermato che non offrirà più i loro servizi al mercato giapponese, sostenendo che le condizioni economiche sfavorevoli siano la causa principale. Di conseguenza, i depositi sono stati sospesi la settimana scorsa e agli utenti giapponesi è stato dato tempo fino a metà febbraio per ritirare le loro partecipazioni.</p>
<h2 id="h2-Tendenze20attuali20del20progetto38399"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>Basandosi sui dati forniti da CoinMarketCap, la maggior parte dei progetti che hanno registrato i maggiori guadagni nella scorsa settimana si sono concentrati sulla risoluzione del trilemma della blockchain, in particolare l’aspetto della scalabilità. Assistendo a una crescita senza precedenti del 3.681% nelle ultime 24 ore, il token Pascal ha dimostrato la maggior quantità di crescita rispetto a qualsiasi altro asset attualmente disponibile sul mercato. È cresciuto di quasi il 7.000% in questa settimana.</p>
<h2 id="h2-Lattuale20trend20del20BTC608868"><a name="L’attuale trend del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’attuale trend del BTC</h2><p>Avendo guadagnato oltre l’11% nell’arco degli ultimi sette giorni, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Attualmente sembra essere in procinto di avere una rottura rialzista, con questa che sembra già essere in programma. A causa della potenziale formazione di una formazione rialzista di incrocio dorato, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> potrebbe continuare a superare le sue recenti performance e accelerare attraverso la zona di resistenza di $23,500 e potenzialmente entrare nella zona chiave di $23,500 e $24,500, secondo l’analista Thescalpingpro, il che potrebbe spingerlo verso massimi rialzisti di $28,100 - uno dei livelli più alti che l’asset abbia visto da oltre sei mesi. Questo potrebbe spingere <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Per entrare in un mercato rialzista, tuttavia, è fondamentale che BTC sia in grado di mantenere l’attuale slancio rialzista per raggiungere questo obiettivo.</p>
<p>Tuttavia, su una nota più rialzista, alcuni analisti hanno anche fatto notare che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> potrebbe trovarsi di fronte alla possibilità della prima croce della morte mai verificatasi nel grafico settimanale, il che comporta un sentimento ribassista. Le attuali condizioni di mercato abbinate a questa inquietante potenziale formazione formano condizioni confrontabili con quelle che hanno caratterizzato la fase ribassista del 2022. Tuttavia, su una nota più positiva, Thescalpingpro osserva anche che il movimento attuale del prezzo del BTC riflette la traiettoria di trading del 2015, in cui il BTC è salito del 214% prima che una croce della morte stesse per essere realizzata. Questo suggerisce in definitiva che c’è una promessa rialzista per il BTC, ma è essenziale essere cauti.</p>
<p>A seguito di questo sentimento misto, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> L’MVRV (valore di mercato rispetto al valore realizzato) di ‘s è aumentato significativamente nell’ultima settimana, rimanendo costantemente sopra la soglia di 1. All’inizio della settimana, l’MVRV di BTC era di 1.079, uno dei valori più alti delle ultime settimane, per poi salire a un massimo di 1.164 il 26. Questo indica che BTC si è finalmente allontanato dall’indicazione di ‘fondo di mercato’ e si sta dirigendo verso un territorio più stabile mentre il suo valore diventa più pienamente realizzato.<br><img src="https://gimg2.gateimg.com/image/article/1674808616111.png" alt=""></p>
<p>Dati settimanali su BTC MVRV (Dati cortesia di Blockchain.com)</p>
<h2 id="h2-Lo20stato20delle20commissioni20di20gas20di20ETH855337"><a name="Lo stato delle commissioni di gas di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato delle commissioni di gas di ETH</h2><p>Al 26 gennaio, c’è stato un moderato calo nel volume totale di gas utilizzato nel corso della settimana precedente rispetto a quello precedente, con la cifra più bassa raggiunta il 26, per un totale di 108.499.288.876. La cifra più alta raggiunta questa settimana è stata il 22, per un totale di 108.891.672.082, dimostrando un utilizzo totale simile a quello visto all’inizio del 2023. Nonostante questo vasto cambiamento nel volume di gas utilizzato, il volume attuale di gas utilizzato sembra essere in linea con le tendenze mensili attuali.</p>
<p>Di conseguenza, i limiti delle commissioni di gas di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> questa settimana hanno registrato un’enorme aumento rispetto alla settimana precedente. I limiti bassi del gas erano compresi tra 10-480 gwei, i limiti medi erano compresi tra 11-573 gwei e i limiti alti erano compresi tra 11-629 gwei - dimostrando una grande disparità nelle commissioni di 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 $311,779.68 o 222.84 ETH), Uniswap: Universal Router (con commissioni totali di $311,331.14 o 164.52 ETH) e <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V2: Router 2 (con commissioni totali di $204,941.96 o 140.03 ETH) - dimostrando così un aumento significativo rispetto alla settimana precedente.</p>
<p>Il costo stimato delle transazioni tra OpenSea: Vendita, Uniswap V3: Scambio e USDT: Trasferimento, è stato suggerito essere compreso tra $1,46 e $5,58, secondo Etherscan.</p>
<h2 id="h2-La20situazione20macro20attuale442080"><a name="La situazione macro attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione macro attuale</h2><p>È stato previsto il tasso di crescita economica più basso degli ultimi decenni</p>
<p>Nella scorsa settimana, la maggior parte dei mercati azionari occidentali ha subito una notevole battuta d’arresto, ulteriormente diminuiti alla luce delle rilascio dei dati che suggeriscono che la crescita della produzione mondiale è destinata a decelerare da una stima del 3% nel 2022, al 1,9% - uno dei tassi di crescita più bassi degli ultimi decenni. Questa notizia è stata comunicata dal World Economic Situation and Prospects (WESP 2023) delle Nazioni Unite, lanciato oggi. Questo rapporto poco incoraggiante ha dipinto un quadro incerto per la scena economica globale nell’anno a venire, considerando in particolare che i dati hanno dimostrato che c’è una minaccia contro il raggiungimento dei 17 Obiettivi di Sviluppo Sostenibile (SDG).</p>
<p>Il Segretario Generale delle Nazioni Unite, Antonio Guterres, ha riconosciuto questo: ‘Questo non è il momento per pensare a breve termine o per attuare una politica di austerità fiscale che aggravi le disuguaglianze, aumenti le sofferenze e possa rendere gli SDG ancora più difficilmente raggiungibili. In questi tempi senza precedenti, è necessaria un’azione senza precedenti.’. Alquanto rassicurante è il fatto che il rapporto abbia previsto che il tasso di crescita internazionale potrebbe raggiungere il 2,7% nel 2024, poiché gli effetti delle recenti crisi globali iniziano a attenuarsi. Tuttavia, questa previsione dipende fortemente dal ritmo e dalla coordinazione di ulteriori misure di restrizione monetaria, dalle conseguenze della guerra in Ucraina e dalla possibilità di ulteriori interruzioni delle catene di approvvigionamento.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire88238"><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 la bullishness generale del mercato e le notizie positive riguardanti l’adozione e la regolamentazione, è molto probabile che la prossima settimana estenda ulteriormente questo slancio e potenzialmente lo sposti fuori dalla minaccia di una trappola per tori. In tal modo, vari asset tra i primi cento continueranno a guadagnare slancio e rigenerare la valutazione, spingendo ulteriormente le criptovalute fuori dal mercato orso.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Matthew Webster-Dowsing</strong>, Ricercatore di Gate.io<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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>