Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgaW5pemlhIGEgc2NlbmRlcmUgdWx0ZXJpb3JtZW50ZSBtZW50cmUgaWwgbWVyY2F0byBhemlvbmFyaW8gc2VndWUgbCdlc2VtcGlvOyBWaXRhbGlrIEJ1dGVyaW4gcml2ZWxhIGwndWx0aW1vICdzZmlkYScgcGVyIEV0aGVyZXVt

2023-01-25, 02:33

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-In20breve153803"><a name="In breve;" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve;</h2><p>🥂 Buongiorno, oggi è mercoledì 25 gennaio 2023. Speriamo che voi abbiate avuto un inizio positivo alla settimana.<br><strong>Sarà un’altra grande giornata, quindi entriamoci subito!</strong></p>
<p>Dopo un forte ingresso settimanale e un’apparente ripresa, il mercato azionario ha iniziato a cadere a seguito della pubblicazione degli utili aziendali e dei sondaggi sull’attività economica, che indicano lo stato attuale dell’economia globale. Ci sono delle preoccupazioni legate all’apertura dell’asta della Borsa di New York. Tuttavia, nonostante ciò, il panorama del mercato azionario asiatico sembra essere solido e sta ancora mostrando una crescita costante.</p>
<p>Crypto: La capitalizzazione di mercato totale secondo Coinmarketcap è di $1,02T, scesa del 2,61% in 24 ore. Poiché la capitalizzazione di mercato è diminuita, così è avvenuto per la maggior parte dei primi venti asset nel corso delle ultime 24 ore, con perdite medie tra l’1 e il 5% a livello di mercato. Questo è probabilmente il risultato della potenziale correzione del mercato azionario abbinata all’aumento dei dati economici e aziendali rilasciati per indicare lo stato di salute dell’economia globale. Tuttavia, <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX) sembra aver sofferto di più nell’ultimo giorno, registrando una perdita totale del 6,87%, per un totale di $16,15. Gli asset che hanno perso un volume simile includono Cosmos (ATOM), Chainlink (LINK) e <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> (UNI).</p>
<p>Argomento del giorno: Vitalik Buterin rivela l’ultimo ‘sfida’ per Ethereum</p>
<p>Titoli degni di nota: gli sviluppatori di <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> affrontano l’incidente che ha causato la breve messa offline dei nodi della blockchain questo fine settimana; Il governo del Regno Unito sta assumendo un leader CBDC; Nayib Bukele risponde ai critici mentre El Salvador paga per intero un debito di 800 milioni di dollari; Whale Stakes di ETH a lungo dormiente 49K ETH; Vitalik Buterin propone un sistema di “indirizzi invisibili” per migliorare la privacy della blockchain.</p>
<h2 id="h2-Macro20in20breve20i20sondaggi20sui20dati20finanziari20delle20aziende20sono20stati20rilasciati20e20dipingono20un20quadro20desolante20per20leconomia20globale784794"><a name="Macro in breve: i sondaggi sui dati finanziari delle aziende sono stati rilasciati e dipingono un quadro desolante per l’economia globale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro in breve: i sondaggi sui dati finanziari delle aziende sono stati rilasciati e dipingono un quadro desolante per l’economia globale</h2><p>Con l’inizio della settimana che sembrava un forte inizio per l’economia internazionale, le cose sono rapidamente cambiate nelle ultime 24 ore, con la maggior parte dei mercati azionari occidentali che hanno subito un colpo alla luce delle pubblicazioni dei dati. La recente comparsa dei guadagni delle imprese e delle indagini sull’attività aziendale ha agito come una testimonianza dell’attuale tumulto dell’economia globale, portando l’insicurezza degli investitori. Di conseguenza, il benchmark di Wall Street S&amp;P 500 ha chiuso la giornata in calo dello -0,10% e il Nasdaq Composite è scivolato triplicando questo valore, facendolo scendere dello -0,30%.</p>
<p>Tuttavia, nonostante questa recente visione negativa, un analista di JPMorgan ha dichiarato che c’è un ‘miglior sentimento sulle prospettive di crescita’, che ha portato l’S&amp;P 500 a raggiungere il suo livello più alto dall’inizio di dicembre lunedì di questa settimana, con tecnologia e azioni del settore dei semiconduttori che si muovono al rialzo. Tuttavia, questa prospettiva positiva è stata rapidamente ridimensionata poiché la banca statunitense ha dichiarato di non aspettarsi che il rally di gennaio in borsa si estenda per il resto del primo trimestre, affermando che: ‘Il recente indebolimento dei dati economici e una prevista diminuzione delle aspettative di guadagno e una debole guida per l’intero anno indicano mercati che probabilmente si muoveranno al ribasso’.</p>
<p>Su una nota più positiva per quanto riguarda i mercati azionari occidentali, è stato riferito dall’analista valutario Lee Hardman di MUFG che i trader hanno ‘nuova fiducia che le banche centrali possano mettere in pausa i loro cicli di rialzo dei tassi’ durante quest’anno poiché le preoccupazioni riguardanti la prospettiva di ulteriore inflazione e una recessione su scala internazionale si sono intensificate. Il suo ottimismo giunge alla luce dell’insistenza degli ufficiali della Federal Reserve degli Stati Uniti e della Banca Centrale Europea che la lotta contro l’inflazione è ancora lontana dall’essere conclusa, come dimostrato dai dati negativi diffusi oggi e dal conseguente colpo subito dal mercato azionario.</p>
<p>Nonostante le attuali turbolenze nei mercati azionari occidentali, una serie di mercati azionari asiatici ha registrato notevoli guadagni nelle ultime 24 ore. La riapertura economica della Cina ha una correlazione positiva con il suo mercato azionario, portando a un aumento del +0,76% nell’ultimo giorno, con questo slancio rialzista che si estende ad Hong Kong e all’India. Di conseguenza, questo, unito alla riduzione delle paure di recessione in Europa e al rallentamento dell’inflazione negli Stati Uniti, sta portando alcuni investitori internazionali a un senso di ottimismo, a prescindere dai dettagli più microeconomici.</p>
<p>Poiché il mercato azionario continua a perdere valore, ciò è indicativo dell’attuale economia globale che è ancora ostacolata dagli effetti a lungo termine della pandemia di COVID-19, dai prezzi del gas e dell’energia in Europa in aumento e dall’inflazione internazionale. Poiché queste ripercussioni continuano a riverberare nei mercati economici globali, sembra che ci siano pochi segni che il mercato azionario emergerà forte e toro, specialmente perché una correzione è imminente.</p>
<p><strong>Mercati di oggi il 24 gennaio 03:21 GMT+8 💡</strong></p>
<p>BTC -1,28% a 22.680,95 dollari; ETH -4,67% a 1.553,37 dollari.</p>
<p>Asia: Australia -0.42%; Giappone -0.02%; Hong Kong +1.82%; Cina +0.76%; India +0.06%.</p>
<p>Europa: Londra -0,28%; Parigi +0,40%; Francoforte -0,07%.</p>
<p>Indici Spot degli Stati Uniti: Dow +0,03%; S&amp;P -1,40%; Nasdaq -0,69%.</p>
<p>Futures degli indici statunitensi: Dow -0,49%; S&amp;P -0,43%; Nasdaq -1,28%.</p>
<p>Il Tesoro statunitense a due anni è in calo dello 0,001% al 4,152%.</p>
<p>Il Tesoro decennale statunitense è in calo dello -0,018% al 3,451%.</p>
<p>Il Bond decennale del Regno Unito ha avuto una variazione del -0,083% ed è al 3,277%.</p>
<p><a href="https://www.gate.io/trade/USD_USDT" target="_blank">US Dollar</a> Indice 0,00% a 101,92.</p>
<p>FX in 24 ore: GBP: -0.15%; EUR: +0.00045%; JPY: +0.07%; CNY: +0.0087%.</p>
<p>Oro +0,10% a 1.937,50; Light Crude +0,14% a 80,24.</p>
<p><strong>Catalizzatori di mercato di questa settimana 🧠</strong></p>
<p>Giovedì: BEA stima PIL per il Q4<br>Venerdì: BEA indice dei prezzi PCE</p>
<p><strong>Catalizzatori della prossima settimana 🗓</strong></p>
<p>Lunedì: dati sull’occupazione/disoccupazione JPN<br>Martedì: S&amp;P HPI Composite, conferenza dei consumatori CB</p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20il20mercato20delle20criptovalute20subisce20ulteriori20ripensamenti20mentre20il20mercato20azionario20ha20unapertura20positiva2020qui20la20stagnazione20di20mercato895366"><a name="Riassunto giornaliero delle criptovalute: il mercato delle criptovalute subisce ulteriori ripensamenti mentre il mercato azionario ha un’apertura positiva; è qui la stagnazione di mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: il mercato delle criptovalute subisce ulteriori ripensamenti mentre il mercato azionario ha un’apertura positiva; è qui la stagnazione di mercato?</h2><p>Con la scena economica globale che è stata ostacolata da dati e sentimenti rialzisti e ribassisti contrastanti, con conseguente significativo calo nei mercati azionari occidentali, sembra che ciò si sia riversato anche sul settore delle criptovalute. Nel corso delle ultime 24 ore, quasi tutti i primi 20 asset hanno subito un notevole calo, perdendo tra l’1% e il 7%. Il drammatico declino del valore dei mercati delle criptovalute è un indicatore che l’onda rialzista che abbiamo visto recentemente spazzare via il mercato potrebbe essere stata solo una moda passeggera e non un segno di un imminente mercato rialzista. Il BTC ha continuato a mantenere la sua posizione sopra i $22.000, tuttavia è diminuito del 1,28% nell’ultimo giorno e cambia di proprietà ad una media di $22.680. Sfortunatamente per Ethereum, però, è diminuito del 4,67%, costringendolo a scendere sotto la soglia dei $1.600 e tornando verso la fascia media dei $1.500. Queste perdite si sono estese su tutto il mercato, portando la capitalizzazione di mercato totale a diminuire del 2,61% a $1,02T.</p>
<p>In notizie correlate, gli sviluppatori di Cardano affrontano l’incidente che ha causato brevemente l’interruzione dei nodi del blockchain questo fine settimana. Durante il fine settimana, la rete Cardano ha subito un’interruzione del 50% sui nodi di rilancio e di produzione di blocchi, con la causa principale attualmente sconosciuta. Si riferisce che la disconnessione e il riavvio di questi nodi siano stati ‘attivati da un’anomalia transitoria’ che ha portato alla disconnessione dei nodi da un peer o al lancio di un’eccezione e al riavvio dei nodi. Tuttavia, gli sviluppatori hanno insistito sul fatto che l’intera rete non è andata giù e che la maggior parte dei nodi interessati si è ‘ripristinata correttamente’.</p>
<p>Inoltre, è stato anche riferito che il governo del Regno Unito ha guardato verso l’assunzione di un responsabile della Central Bank Digital Currency (CBDC) per prendere il controllo della ‘direzione strategica’ del tesoro del Regno Unito mentre cercano di creare e distribuire una libbra digitale efficace. Questo avviene alla luce dell’inizio del governo del Regno Unito di una ulteriore repressione della regolamentazione delle criptovalute mentre la pressione aumenta dalla creazione da parte dell’UE della politica MiCA, che dovrebbe essere applicata a partire da giugno di quest’anno.</p>
<p>Tra le prime 20 monete, la maggior parte ha subito perdite, nonostante l’incremento principalmente positivo del valore su base settimanale. Avalanche ha registrato le maggiori perdite nelle ultime 24 ore, perdendo il 6,87% e scambiando a una media di $16,95. Senza che nessuna delle prime 20 risorse abbia avuto un attimo di tregua da questa improvvisa ondata ribassista, è probabile che questo momento possa interrompere ciò in cui gli investitori credevano essere l’uscita dall’inverno criptato.</p>
<p>Con il mercato delle criptovalute che ora riflette nuovamente il graduale declino del mercato azionario occidentale, è plausibile che le prestazioni di quest’ultimo nei prossimi giorni abbinate ai dati economici globali possano iniziare a influenzare negativamente ulteriormente le prestazioni del mercato delle criptovalute. Ciò potrebbe dissipare i rumors secondo cui l’ultima ondata rialzista era indicativa dell’inizio di un mercato rialzista e mostrare invece che l’inverno delle criptovalute è ben lungi dall’essere finito.</p>
<p><strong>Performance delle prime 20 criptovalute 🌐</strong></p>
<p>BTC -1.28% a $22,680.95; ETH -4.67% a $1,553.37.<br>BNB -1.23% a $301.91; <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> -4.20% a $0.4052; DOGE -5.28% a $0.08401.<br>ADA -5.56% a $0.3548; MATIC -3.90% a $0.9545; DOT -6.58% a $6.15.<br>TRX -4.66% a $0.06; SHIB -6.74% a 0.00001119 LTC -3.76% a $86.79.<br>SOL -5.41% a $22.90; UNI -6.74% a $6.25; AVAX -6.87% a $16.95.<br>ATOM -5.09% a $12.39; <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> -5.19% a $6.67.</p>
<h2 id="h2-Argomento20del20giorno20Vitalik20Buterin20svela20lultimo20sfida20per20Ethereum898956"><a name="Argomento del giorno: Vitalik Buterin svela l’ultimo ‘sfida’ per Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argomento del giorno: Vitalik Buterin svela l’ultimo ‘sfida’ per Ethereum</h2><p>Con l’imminente aggiornamento di Shanghai e la riuscita esecuzione della fusione, la rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sembra adottare un approccio pratico per affrontare le sue lacune operative come mezzo per migliorare la sua tecnologia e quella della più ampia tecnologia blockchain. Nello sforzo di costruire meglio su questa missione, Vitalik Buterin ha riconosciuto la crescente necessità di creare una soluzione per la privacy, perché per impostazione predefinita tutte le informazioni che vengono inserite in una blockchain pubblica sono rese pubbliche anche. Ciò ha portato Buterin a proporre il concetto di ‘indirizzi stealth’, che hanno il potenziale per aggiungere uno strato di anonimato alle transazioni peer-to-peer, ai trasferimenti NFT e alle registrazioni del servizio Ethereum Name (ENS).</p>
<p>Elaborando ulteriormente il concetto, Buterin ha spiegato che sarebbe necessario implementare uno “scambio di chiavi Diffie-Hellman” abbinato a un “meccanismo di accecamento delle chiavi” per garantire che il collegamento tra un indirizzo stealth e il meta-indirizzo di un utente possa essere visto pubblicamente. In sostanza, questo promuove ancora la trasparenza decentralizzata, garantendo al contempo che le informazioni sulle transazioni e sugli utenti possano rimanere private e sicure. Tuttavia, Buterin ha anche riconosciuto i “problemi di usabilità a lungo termine”, compresi i problemi di ripresa sociale, ma rimane fiducioso che questi problemi potrebbero essere risolti in tempo.</p>
<p>Ethereum (ETH) $1,538.32 (-4.67%) - Prospettiva neutra</p>
<h2 id="h2-Ethereum20ETH20Panoramica921848"><a name="Ethereum (ETH) Panoramica:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH) Panoramica:</h2><p><strong>Zona di supporto giornaliero più vicina: </strong>1.562,75-1.630</p>
<p><strong>Zona di resistenza giornaliera più vicina:</strong> 1.611,75-1.595</p>
<p><strong>
</strong>Livello chiave: $0,4304 (massimo mensile di gennaio 2023)**</p>
<p><strong>Zone di resistenza quotidiana:</strong></p>
<p>1.553,84-1.566,03<br>1.611,75-1.595<br>1.629,71-1.636,4</p>
<p><strong>Zone di supporto giornaliere:</strong></p>
<p>1.633-1.639<br>1.611,21-1.622,92<br>1.549-1.556,75</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674613770unnamed0125.png" alt=""><br>Dati per gentile concessione di CoinMarketCap</p>
<p>A partire da oggi, ETH ha preso una svolta notevolmente ribassista, emergendo in un trend al ribasso nei prossimi giorni. Dopo aver aperto la giornata a una media di $1.637, ETH ha iniziato a scambiare lateralmente prima di affondare sotto la sua SMA a 7 giorni e cadere vittima della volatilità, portandolo in una spirale che lo ha costretto sotto la zona dei $1.600 che i tori hanno combattuto per superare, e nuovamente nelle regioni superiori della zona dei $1.500.</p>
<p>Tuttavia, mentre questo improvviso trend al ribasso è incongruente con le prestazioni di Ethereum nei giorni scorsi, Ethereum rimane comunque al di sopra della soglia di prezzo a cui stava scambiando in questo momento la settimana scorsa, quando l’onda rialzista aveva preso il mercato a pieno regime. Ciò suggerisce che nonostante l’attuale momento al ribasso, Ethereum potrebbe ancora trovarsi in un territorio di prezzo promettente, specialmente quando si confrontano questi dati con la traiettoria al rialzo dimostrata nell’ultimo mese. In generale, questo attuale calo potrebbe indicare una correzione minore del prezzo dell’asset.</p>
<p>Si può affermare che con la crescente copertura mediatica di Ethereum e l’imminente Aggiornamento di Shanghai, l’asset potrebbe continuare a guadagnare slancio positivo sui prezzi e potrebbe proseguire il suo trend positivo mensile nel valore senza essere suscettibile alle condizioni di mercato ribassiste.</p>
<h2 id="h2-Ulteriori20letture9799"><a name="Ulteriori letture" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ulteriori letture</h2><p><strong>Gate.io 2023: Concentrarsi nuovamente sui Fondamentali</strong> | Il nostro fondatore, Lin Han, parla delle iniziative di beneficenza di Gate e degli obiettivi per il nuovo anno.</p>
<p><strong>Attenzione alle truffe NFT: come distinguere gli NFT veri e falsi?</strong> | Ci sono 7 modi per dire la verità sugli NFT per tenerti lontano dalle truffe sugli NFT</p>
<p><strong>ChatGPT AI impatti la sanità, i prezzi in aumento colpiscono gli americani, le politiche redistributive della Cina influenzano gli sviluppatori immobiliari</strong> Come abbiamo visto in passato, gli eventi globali e il mondo delle criptovalute sono spesso interconnessi.</p>
<h2 id="h2-Titoli20notevoli596869"><a name="Titoli notevoli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Titoli notevoli</h2><p>🔹<br><strong>Gli sviluppatori di Cardano affrontano l’incidente che ha causato brevemente offline i nodi della blockchain questo fine settimana.</strong></p>
<p>🔹<br><strong>Il governo del Regno Unito sta assumendo un responsabile per la CBDC</strong> per il loro team del tesoro per determinare la ‘direzione strategica’ per il futuro sterlina digitale.</p>
<p>🔹<br><strong>Nayib Bukele risponde duramente ai critici mentre El Salvador paga un debito di 800 milioni di dollari</strong> in pieno dopo la diffusione di notizie sui suoi default.</p>
<p>🔹 <strong>Una balena ETH inattiva da tempo ha staked 49K ETH </strong>, portando gli analisti a sperare che una maggiore partecipazione allo staking di ETH possa portare a <a href="https://www.gate.io/trade/ETH_USDT" target="_blank">prezzo ETH</a> rally.</p>
<p>🔹<strong>Vitalik Buterin propone un sistema di ‘indirizzo stealth’</strong> per migliorare la privacy della blockchain come mezzo per offrire le stesse proprietà di privacy della generazione di un nuovo indirizzo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Matthew Webster-Dowsing</strong>, Ricercatore 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 venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>