Tm90aXppZSBxdW90aWRpYW5lIHwgT3JzaSBkZWwgbWVyY2F0byBjcml0dG9ncmFmaWNvIHNvcHBvcnRhbm8gbCdhdW1lbnRvIGRlbGxlIHByZXN0YXppb25pIGVjb25vbWljaGUgZ2xvYmFsaSwgaWwgU2FuZGJveCB2b2xhIGluIHZvbHVtZQ==

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-TL20DR593073"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>🥂 Buongiorno, oggi è lunedì 23 gennaio 2023. Speriamo che voi ragazzi abbiate trascorso un weekend riposante! Sarà un’altra giornata fantastica, quindi cogliamola!</p>
<p>Macro: L’Euro ha iniziato a riprendersi dopo essere sceso sotto la pari con il <a href="https://www.gate.io/trade/USD_USDT" target="_blank">US Dollar</a> all’inizio del Q4 del 2022, da allora è cresciuto di oltre il 13%. I prezzi del gas naturale in Europa hanno iniziato a diminuire a causa del clima più caldo, attenuando le preoccupazioni di una profonda recessione a livello continentale nel 2023. Dall’altra parte della costa, è stato riferito dai meteorologi che l’economia statunitense dovrebbe diminuire nel secondo e nel terzo trimestre, nonostante le probabilità di recessione del prossimo anno si attestino al 65%.</p>
<p>Crypto: La capitalizzazione di mercato totale secondo Coinmarketcap è di 1,05 T, con una diminuzione dello 0,5% nelle ultime 24 ore. Alla luce della migliorata situazione economica globale, la maggior parte dei primi 20 asset ha registrato guadagni fino al 10% questa settimana, tuttavia molti hanno subito piccole perdite nelle ultime 24 ore. Ciò è probabilmente dovuto alle preoccupazioni che l’inflazione continuerà a svolgere un ruolo critico nel primo trimestre del 2023. È importante monitorare attentamente la situazione macro migliorata per vedere se ciò correla negativamente con il mercato delle criptovalute e smorza il momento rialzista visto nelle ultime settimane.</p>
<p>Argomento del giorno: <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> riporta vendite di terreni record in aumento di popolarità</p>
<p>Titoli Notabili: 2,5 Trilioni di <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> (SHIB) sono stati presi dalle Balene durante la notte; <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> di Ripple guadagna forza mentre si avvicina la decisione della SEC; Il Ministro degli EAU afferma che le criptovalute giocheranno un ruolo importante nel commercio degli EAU in futuro; Il tasso di occupazione negli Stati Uniti rimane forte e l’inflazione sta diminuendo nonostante le preoccupazioni per la recessione.</p>
<h2 id="h2-Macro20in20sintesi20i20mercati20globali20si20prevede20che20abbiano20un20inizio20positivo20alla20settimana2020sicuro20ricominciare20a20comprare587406"><a name="Macro in sintesi: i mercati globali si prevede che abbiano un inizio positivo alla settimana; è sicuro ricominciare a comprare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro in sintesi: i mercati globali si prevede che abbiano un inizio positivo alla settimana; è sicuro ricominciare a comprare?</h2><p>Nonostante il mercato azionario più ampio abbia dimostrato un miglioramento delle prestazioni durante il fine settimana, il mercato azionario statunitense è attualmente avvolto da sentimenti misti degli investitori poiché le forti performance iniziano a rallentare. Ciò ha sollevato la domanda ‘quando sarà sicuro iniziare a comprare di nuovo?’.</p>
<p>Gli analisti hanno osservato che il rallentamento dell’inflazione potrebbe consentire alla Federal Reserve di rilassare il ciclo aggressivo di aumenti dei tassi di interesse. Tuttavia, la minaccia di una recessione e ulteriori aumenti dell’inflazione negli Stati Uniti è lontana dall’essere scomparsa, poiché il Dipartimento del Tesoro degli Stati Uniti ha adottato misure straordinarie per soddisfare gli obblighi del paese dopo che il limite di debito deciso dal Congresso è stato raggiunto, con la Segretaria al Tesoro, Janet Yellen, che crede che le misure impediranno un default degli Stati Uniti fino a giugno.</p>
<p>Con i mercati americani che sono stati recentemente afflitti da un sell-off a Wall Street, il mercato azionario è attualmente un miscuglio, con titoli del calibro di S&amp;P e Nasdaq che hanno guadagnato tra l’1 e il 2,8% a partire da venerdì, con altri che hanno effettuato notevoli rialzi. Tuttavia, la maggior parte dei principali indici ha chiuso la settimana in ribasso, suggerendo che i timori di recessione si sono tradotti in un sentimento ribassista in tutti i mercati.</p>
<p>Venerdì è stato riferito che il mercato azionario asiatico si è progressivamente orientato al rialzo, con Cina, Giappone e Australia tutti a conoscenza di un trend positivo alla luce delle stime degli utili in aumento e delle iniziative per stimolare le prospettive economiche della Cina su base regionale. In gran parte, l’Asia è rimasta indifferente ai sentimenti contrastanti provenienti dagli Stati Uniti. Tuttavia, a deviare da questa tendenza è stata l’India, con il mercato azionario di Mumbai che ha riportato perdite moderate in mezzo alla volatilità.</p>
<p>Nel Regno Unito, i tassi di inflazione sono scesi al 10,5%, da un massimo dell’11,10% registrato a ottobre. Nonostante questo calo, l’attuale tasso di inflazione si avvicina ai massimi degli ultimi 40 anni e i prezzi sono ancora in forte crescita. L’inflazione nel Regno Unito e in gran parte dell’Europa è stata attribuita alle ricadute della pandemia, al conflitto in Ucraina e Russia e all’impennata dei prezzi del gas e dell’energia in Europa. Questo ritratto dell’inflazione si estende attualmente a gran parte dell’Europa.</p>
<p><strong>I mercati di oggi il 23 gennaio 03:21 GMT+8 💡</strong><br>BTC -1,75% a $22.819,87; Ether -1,10% a $1.644,41<br>Asia: Australia +0,23%; Giappone +0,56%; Hong Kong +1,82%; Cina +0,76%; India -0,44%<br>Europa: Londra +0,08%; Parigi +0,40%; Francoforte +0,76%<br>Indici spot USA: Dow +1,48%; S&amp;P +1,24%; Nasdaq +2,86%<br>Futures indici USA: Dow +0,27%; S&amp;P +1,05%; Nasdaq +2,82%<br>Il Tesoro USA a due anni è salito del +0,059% al 4,09%<br>Il Tesoro USA a dieci anni è salito del +0,083 al 3,4840%<br>Il Gilt Bond del Regno Unito a dieci anni non ha subito variazioni ed è al 3,378%<br><a href="https://www.gate.io/trade/USD_USDT" target="_blank">US Dollar</a> Indice -0.07% a 101,99<br>FX in 24 ore: GBP: +0,12%; EUR: +0,47%; JPY: -0,90%; CNY: 0,00%<br>Oro +1,11% a 1.925; Petrolio leggero +0,11% a 81,40</p>
<p><strong>Catalizzatori di mercato questa settimana 🧠</strong><br>Martedì: S&amp;P Global Composite PMI per gennaio<br>Giovedì: BEA emette la stima del PIL per il Q4<br>Venerdì: Indice dei prezzi PCE del numero BEA</p>
<p><strong>Catalizzatori della prossima settimana 🗓</strong><br>Lunedì: dati sull’occupazione e sulla disoccupazione in Giappone Martedì: indice S&amp;P HPI Composite, conferenza dei consumatori CB</p>
<h2 id="h2-Crypto20Daily20Digest20Il20mercato20delle20criptovalute20subisce20un20piccolo20calo20mentre20i20mercati20globali20si20aspettano20unapertura20positiva20il20rally20rialzista2020una20trappola20rialzista840187"><a name="Crypto Daily Digest: Il mercato delle criptovalute subisce un piccolo calo mentre i mercati globali si aspettano un’apertura positiva: il rally rialzista è una trappola rialzista?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il mercato delle criptovalute subisce un piccolo calo mentre i mercati globali si aspettano un’apertura positiva: il rally rialzista è una trappola rialzista?</h2><p>Con i mercati economici internazionali che sono stati avvolti da sentimenti contrastanti, la maggior parte del mercato delle criptovalute è stata soggetta a perdite nelle ultime 24 ore. Con una leggera flessione del -2,75%, il BTC si mantiene stabile sopra la soglia dei $22k a $22.577,19. Anche l’ETH ha subito perdite simili del -2,22% e si posiziona sopra la soglia dei $1.600 a $1.623,24. La capitalizzazione totale del mercato delle criptovalute, secondo i dati forniti da Coinmarketcap, si mantiene forte a $1.05T, avendo subito un calo del -1,6% nell’ultimo giorno, il che implica che l’attuale ondata rialzista potrebbe stentare di fronte ai cambiamenti macro.</p>
<p>In altre notizie, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ha registrato un aumento dell’83% nel numero totale di sviluppatori, secondo un rapporto di Electric Capital, segnalando che nonostante il suo crollo devastante nel Q4 del 2023, il sentiment attorno alla rete Solana rimane rialzista poiché lo sviluppo deve ancora rallentare. Allo stesso modo, <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> ha registrato un aumento del 40% di sviluppatori, Cosmos ha registrato un aumento del 25% e <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> ha registrato un aumento del 2%.</p>
<p>Inoltre, un solo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il minatore ha segnalato di aver risolto un blocco con un tasso di hash di soli 10 TH/s, aggiungendo il blocco 772.793 alla rete. Al momento dell’aggiunta del blocco, il tasso di hash totale di BTC era leggermente superiore a 269 exahash al secondo, il che significa che i 10 TH/s del minatore rappresentavano solo lo 0,000000037% della potenza computazionale dell’intera blockchain. Sconfiggendo probabilità improbabili, il minatore ha ricevuto il 98% dei totali 6,35939231 BTC assegnati come ricompensa per il blocco e le commissioni, mentre il restante 2% è andato a Solo CK Protocol, un servizio di mining online che facilita il mining individuale.</p>
<p>Tra le prime 20 monete, la maggioranza ha subito perdite, nonostante l’impennata predominante di valore su scala settimanale. Solana ha registrato le maggiori perdite nelle ultime 24 ore, perdendo il 6,17% e totalizzando $24,02. Tuttavia, è stata UNI ad andare contro ogni pronostico e aumentare del +1,79% a $6,89 mentre il resto delle prime venti faticava a recuperare le perdite.</p>
<p>Con gli analisti che prevedono un’imminente correzione del volume degli scambi dei mercati azionari tradizionali, che hanno un volume di scambi superiore di oltre 100 volte rispetto alle criptovalute, ci si aspetta che ciò possa avere un effetto sull’intero mercato crittografico. È fondamentale monitorare il mercato e vedere se i cali attuali dei prezzi sono indicativi del fatto che l’attuale ondata rialzista potrebbe essere una trappola mentre la correzione incombe.</p>
<p><strong>Prestazioni delle prime 20 monete 🌐</strong><br>BTC -2,75% a $22.577,19; ETH -2,22% a $1.623,24.<br>BNB -0,85% a $301,71; XRP -2,64% a $0,4014; DOGE +0,68% a $0,088.<br>ADA +1,61% a $0,3808; MATIC -1,93% a $0,9937; DOT -3,47% a $6,19.<br>TRX -0,94% a $0,06171; SHIB -1,32% a 0,00001204 LTC -2,62% a $87,69.<br>SOL -6,17% a $24,02; UNI +1,79% a $6,89; AVAX +0,64% a $17,45.<br>ATOM -0,81% a $13,30; <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> -0,53% a $6,96.</p>
<h2 id="h2-Argomento20del20giorno20The20Sandbox20segnala20vendite20di20terreni20record20in20aumento20di20popolarit450588"><a name="Argomento del giorno: The Sandbox segnala vendite di terreni record in aumento di popolarità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argomento del giorno: The Sandbox segnala vendite di terreni record in aumento di popolarità</h2><p>The Sandbox ha riportato livelli record di vendite di terreni, guadagnandosi l’ingresso nella lista degli smart contract più utilizzati tra le prime 100 balene di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> nelle ultime 24 ore. WhaleStats ha confermato che The Sandbox ha ricevuto un’attenzione particolare da parte delle balene, indicando che il mondo del metaverso sta vivendo un flusso di valore e un afflusso di domanda per i suoi appezzamenti di terreno virtuali.</p>
<p>A testimonianza della sua crescita negli ultimi mesi, il team di The Sandbox ha riferito che le sue vendite di NFT immobiliari hanno registrato una sostanziale crescita del 180% su base annua, con circa 1,4 miliardi di dollari di vendite durante questo periodo, portando la capitalizzazione di mercato fondiaria di The Sandbox a 167 milioni di dollari. Questo ha posizionato The Sandbox come il terzo più grande fornitore di metaverso, dietro <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> e Otherside.</p>
<p>Con la maggior parte di questa attività di trading che si verifica nel corso del mercato ribassista, questo aumento delle vendite di NFT non è riuscito a correlarsi con la sua capitalizzazione di mercato. Negli ultimi sei mesi, la capitalizzazione di mercato di SAND è scesa in linea con altri asset a causa delle condizioni di mercato ribassiste. Tuttavia, quando l’ondata rialzista ha iniziato a prendere il sopravvento sul mercato, SAND ha iniziato a recuperare un po’ di valore in un sano periodo di recupero di tre settimane.</p>
<h2 id="h2-Sandbox20SAND20Overlook174283"><a name="Sandbox (SAND) Overlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sandbox (SAND) Overlook</h2><p><strong>The Sandbox (SAND) $0,8253 (+2,95%) - Prospettive neutrali</strong></p>
<p><strong>Zona di supporto giornaliero più vicina: 0.7974-0.8091</strong><br><strong>Zona di resistenza giornaliera più vicina: 0.8376-0.8455</strong><br><strong>Livello chiave: $0.8455 (Massimo mensile di gennaio 2023)</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/16744375988121674437553_.pic.jpg" alt=""><br>Dati forniti da TradingView</p>
<p>Attualmente, SAND è in aumento del promettente 118% rispetto al suo minimo di 12 mesi e sta iniziando ad avvicinarsi alla sua media mobile a 200 giorni, tuttavia, sta procedendo in modo caotico verso territori ipercomprati, il che potrebbe avere un effetto inverso sul suo valore e impedire di toccare la media mobile.</p>
<p>Su una nota ribassista simile, è stato notato che l’accumulo degli indirizzi principali di SAND è aumentato notevolmente nella prima parte di gennaio. Tuttavia, questo volume è drasticamente diminuito dal 19 gennaio, probabilmente poiché le balene e gli indirizzi principali iniziano a incassare seguendo la recente impennata rialzista. Prima di questo, l’età media della moneta ha cambiato direzione, il che significa che SAND passava di mano in mano regolarmente, ma non c’erano vendite significative che potessero innescare un’importante correzione al ribasso.</p>
<p>È possibile che SAND possa continuare a salire per un po’ di tempo, soprattutto se il mondo metaverso continua a crescere organicamente e a attirare l’attenzione di coloro che guardano di nuovo verso il metaverso mentre il mercato inizia a riprendersi. Tuttavia, con SAND che rischia pericolosamente di entrare nella fascia di ipercomprato, potrebbe scatenarsi un ritracciamento del valore.</p>
<p>Zone di resistenza giornaliera di SAND:<br>0.7895-0.8012<br>0.804-0.8069<br>0.8376-0.8455</p>
<p>Zone di supporto giornaliero di SAND:<br>0.782-0.7878<br>0.8-0.804<br>0.8202-0.8315</p>
<h2 id="h2-Ulteriori20letture369286"><a name="Ulteriori letture" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ulteriori letture</h2><p><a href="https://www.gate.io/blog_detail/2069/gateio-2023-focus-back-on-the-fundamentals" target="_blank">Gate.io 2023: Concentrarsi di nuovo sui Fondamentali</a> Il nostro fondatore, Lin Han, affronta le iniziative di beneficenza di Gate e gli obiettivi per il nuovo anno.</p>
<p><a href="https://www.gate.io/blog_detail/2066/distinguish-nft-scams" target="_blank">Fate attenzione alle truffe NFT - Come distinguere il vero NFT dal falso?</a> | Ci sono 7 modi per dire la verità sugli NFT per tenerti lontano dalle truffe sugli NFT</p>
<p><a href="https://www.gate.io/blog_detail/2064/chatgpt-ai-impacts-healthcare-rising-prices-hit-americans-chinas-redistributive-policies-affect-property-developers" target="_blank">L’IA di ChatGPT influenza l’assistenza sanitaria, i prezzi in aumento colpiscono gli americani, le politiche redistributive della Cina influenzano gli sviluppatori immobiliari</a> Come abbiamo visto in passato, gli eventi globali e il mondo delle criptovalute sono spesso interconnessi.</p>
<h2 id="h2-Titoli20notevoli118669"><a name="Titoli notevoli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Titoli notevoli</h2><p>🔹 Il protocollo di prestito Terra, Mars, lancerà il suo mainnet sulla blockchain di Cosmos il 31 gennaio, insieme all’emissione di token MARS agli utenti che li detengono durante i due snapshot su <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Classic.</p>
<p>🔹 FlintWallet aggiunge il supporto per Milkomeda poiché cerca di diventare un portafoglio basato su <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> completamente compatibile con qualsiasi rete blockchain.</p>
<p>🔹 Le balene di Ethereum accumulano $422.000.000 di SHIBA in meno di una settimana, aumentando le loro partecipazioni del 151% in questo periodo. SHIBA è ora l’asset digitale più detenuto dalle prime 1.000 balene ETH.</p>
<p>🔹 Il ministro degli Emirati Arabi Uniti afferma che le criptovalute giocheranno un ruolo ‘importante per il commercio degli Emirati Arabi Uniti in futuro’ in una recente conferenza. Ciò è stato seguito dalla dichiarazione del ministro secondo cui la ‘governance globale’ è la cosa più importante in avanti.</p>
<p>Il numero di sviluppatori di Solana è aumentato del 83% nei mesi scorsi, segnalando che lo sviluppo della rete è in corso, nonostante il suo recente crollo.</p>
<p>🔹Dogecoin riduce le emissioni di CO2 del 25%, rendendolo la terza criptovaluta più veloce nel ridurre la propria impronta di carbonio.</p>
<p>🔹 Il rapporto mostra che più reti di layer-2 di Ethereum stanno crescendo, con Polygon in testa con un aumento dell’attività utente giornaliera del 30%.</p>
<p><a href="https://www.gate.io/activities/crypto-news-carnival#/ &quot;![](https://gimg2.gateimg.com/blog/166564757654240488320221013-155245.png" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/blog/166564757654240488320221013-155245.png" alt=""></a>”)</p>
<div class="blog-details-info"><br><div>Autore: <strong>Matthew W-D</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>