Tm90aXppZSBxdW90aWRpYW5lIHwgSSBwYWVzaSBkZWwgRzIwIHBpYW5pZmljYW5vIGxvIHNjYW1iaW8gZGkgaW5mb3JtYXppb25pIGNyaXB0YXRlIGEgcGFydGlyZSBkYWwgMjAyNywgaWwgbWVyY2F0byBkZWwgZG9sbGFybyBzdGFiaWxlIGRpIFBheVBhbCBzdWJpc2NlIHVuYSBmbGVzc2lvbmUsIGlsIHZvbHVtZSBkaSB0cmFkaW5nIGR

2023-09-12, 04:08

<p><img src="https://gimg2.gateimg.com/image/article/16944968770912.jpg" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20i20paesi20del20G2020pianificano20di20scambiare20informazioni20sulle20criptovalute20a20partire20dal20202720il20mercato20del20dollaro20stabile20di20PayPal20negli20Stati20Uniti20sta20affrontando20una20fase20di20calo707418"><a name="Riassunto giornaliero delle criptovalute: i paesi del G20 pianificano di scambiare informazioni sulle criptovalute a partire dal 2027, il mercato del dollaro stabile di PayPal negli Stati Uniti sta affrontando una fase di calo." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: i paesi del G20 pianificano di scambiare informazioni sulle criptovalute a partire dal 2027, il mercato del dollaro stabile di PayPal negli Stati Uniti sta affrontando una fase di calo.</h2><p>I leader dei paesi membri del G20 hanno recentemente tenuto un vertice nella capitale indiana, New Delhi, per raggiungere un consenso sulla rapida attuazione di un quadro transfrontaliero per gli asset criptati. Il quadro promuoverà lo scambio globale di informazioni sugli asset criptati a partire dal 2027, con i paesi che scambieranno automaticamente informazioni sulle transazioni criptate tra diverse giurisdizioni ogni anno, inclusa le transazioni effettuate su borse di criptovalute non regolamentate e fornitori di portafogli.</p>
<p>Secondo la dichiarazione di consenso raggiunta al vertice, il Global Forum for Transparency and Tax Information Exchange stabilirà un calendario appropriato e coordinato. Le giurisdizioni rilevanti determineranno il calendario degli scambi, che influenzerà Argentina, Australia, Brasile, Canada, Cina, Francia, Germania, India, Indonesia, Italia, Giappone, Messico, Russia, Arabia Saudita, Sudafrica, Corea del Sud, Türkiye, Gran Bretagna e Stati Uniti, nonché paesi come l’Unione Europea.</p>
<p>Secondo l’ultimo rapporto di mercato sulle criptovalute di agosto rilasciato da Dapprader, la stablecoin PYUSD in dollari statunitensi di PayPal ha incontrato una fredda accoglienza nel mercato nel suo primo mese di lancio, con un volume di trading giornaliero medio inferiore a $100.000. Inoltre, il tasso di adozione di PYUSD è anche superficiale, con solo un portafoglio non di trading che detiene token superiori a $10.000 finora.</p>
<p>Il rapporto ha anche rivelato che un’altra stablecoin in dollari statunitensi, USDC, è approdata sulla catena Base all’inizio di settembre, ma il suo valore di mercato è diminuito del 50% negli ultimi 14 mesi. Tuttavia, Circle ha pianificato di implementare USDC su <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> e altre quattro blockchain entro novembre.</p>
<p>D’altra parte, i dati da Shibarium scan mostrano che da giovedì scorso, il numero di transazioni di Shibarium è più che raddoppiato, passando da un massimo di 88.630 a 177.050 solo nelle ultime 24 ore. Questo picco ha portato il numero totale di transazioni attraverso il blockchain durante questo periodo a 420.000.</p>
<p>Secondo i dati di ultrasound.money, l’emissione di ETH della scorsa settimana è stata di 15.559 ETH, maggiore del volume di distruzione (11.374 ETH). Attualmente, ETH si trova in uno stato inflazionistico, con un tasso di inflazione annuale dello 0,18% basato sul livello di inflazione degli ultimi 7 giorni.</p>
<p>In risposta, gli analisti di Matrixport credono nell’ultimo rapporto di mercato che a causa di una crescita dei ricavi inferiore alle aspettative, soprattutto quando <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> si avvicina al livello psicologicamente importante di $1.600, una svolta potrebbe portare a un calo dei prezzi.</p>
<p>Secondo il monitoraggio di Ali Charts, il 9 settembre, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> aggiunte 717.331 nuovi indirizzi, raggiungendo il livello più alto degli ultimi cinque anni. L’ultimo picco di nuovi indirizzi <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> rilevati in un singolo giorno è stato il 14 dicembre 2017, quando sono stati aggiunti 800.180 indirizzi Bitcoin.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi743540"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC841228"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1694496910BTC.png" alt=""><br>Come previsto, la struttura del prezzo di Bitcoin ha rotto al di sotto del livello di supporto critico di $25,281. Inoltre, deve ancora riprendersi rapidamente sopra la neckline di $25,281. Una strategia conservativa suggerisce di prendere profitto in questo punto, mentre un approccio più aggressivo potrebbe considerare una prospettiva ribassista sostenuta verso l’obiettivo iniziale di $24,225. L’utilizzo di uno stop loss dinamico può servire come strategia di uscita difensiva.</p>
<h3 id="h3-OAX804012"><a name="OAX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OAX</h3><p><img src="https://gimg2.gateimg.com/image/article/1694496928OAX.png" alt=""><br>OAX ha raggiunto il suo massimo storico a $0.5405. Una struttura di medio termine indica il completamento di un modello di fondo arrotondata e nel breve termine è probabile che testi il livello di resistenza a $0.1989. Stare attenti a vedere se riesce a superare $0.1960, che potrebbe presentare un’opportunità per il trading di breakout con target a $0.2043 e $0.2268.</p>
<h3 id="h3-TORN660129"><a name="TORN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TORN</h3><p><img src="https://gimg2.gateimg.com/image/article/1694496946TORN.png" alt=""><br>Come uno dei principali progetti nello spazio del protocollo mixed-coin, TORN ha subito un significativo calo dal suo massimo storico di $948,8 al suo attuale livello di $2,83, rappresentando una sostanziale diminuzione del 99,69%. Dopo una falsa rottura, si è verificato un rapido retracemento e convergenza alla fine. Continueremo a monitorare il comportamento del mercato alla fine del modello. Il livello di supporto inferiore suggerito da mantenere è di $2,65, con potenziali obiettivi indicati dalle linee gialle.</p>
<h2 id="h2-Macro20Linflazione20non2020ottimistica20e20la20politica20monetaria20della20Federal20Reserve20sta20affrontando20difficolt619252"><a name="Macro: L’inflazione non è ottimistica, e la politica monetaria della Federal Reserve sta affrontando difficoltà" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’inflazione non è ottimistica, e la politica monetaria della Federal Reserve sta affrontando difficoltà</h2><p>Questa settimana, tutti saranno concentrati sull’Indice dei prezzi al consumo (CPI) di agosto pubblicato mercoledì, specialmente dopo che il tasso di inflazione è sceso significativamente dal 9,1% a giugno 2022 al poco più del 3% a luglio. Il mercato è in attesa dei dati CPI nei prossimi mesi per consolidare l’inflazione e tornare a un livello vicino all’obiettivo del 2% della Fed, aprendo così la strada alla Fed per smettere di aumentare i tassi di interesse e iniziare a ridurli già l’anno prossimo.</p>
<p>Ma Mohamed El-Erian, consulente economico capo del Gruppo Allianz, ha scritto lunedì che purtroppo la realtà dell’ultimo miglio nella attuale lotta all’inflazione potrebbe essere ancora più complessa.</p>
<p>In breve, il forte trend anti-inflazionistico nel 2023 è stato guidato dall’industria delle materie prime, con alcune materie prime come l’energia che hanno registrato un forte calo dei prezzi, che è continuato sulla base di una diminuzione di elementi più ostinati come l’affitto. Da una prospettiva più ampia, poiché i servizi vengono aggiunti all’anti-inflazione dei beni, l’inflazione di base deve rimanere bassa, riaffermando così un ambiente di inflazione bassa e stabile.</p>
<p>Nel miglior scenario possibile, con l’inflazione in diminuzione e la Federal Reserve che continua a ridurre il proprio bilancio, i livelli di interesse attuali diventeranno più restrittivi.</p>
<p>La Federal Reserve taglierà i tassi di interesse e, in caso di un’economia inaspettatamente forte, sconfiggere l’inflazione non causerà alcuna perdita alla crescita economica o alla stabilità finanziaria.</p>
<p>Inoltre, la Federal Reserve di New York ha riferito lunedì che la visione generale dell’inflazione tra gli americani è leggermente cambiata ad agosto. Tuttavia, ci sono segnali di una ripresa delle aspettative di inflazione a lungo termine. Nel frattempo, le percezioni delle famiglie sulle condizioni finanziarie attuali e le aspettative per il futuro sono nettamente peggiorate. Prevedono che i prezzi come l’affitto, i prezzi delle abitazioni e il cibo aumenteranno.</p>
<p>Nel suo sondaggio sul sentiment dei consumatori di agosto, la Federal Reserve di New York ha dichiarato che le aspettative di inflazione sono state relativamente stabili il mese scorso, con i partecipanti che si aspettano un tasso di inflazione del 3,6% entro un anno, più alto del 3,5% di luglio, invertendo i precedenti quattro mesi consecutivi di calo. Questa serie di dati è di solito un indicatore proxy per i prezzi del petrolio.</p>
<p>Si prevede che il tasso di inflazione raggiunga il 2,8% entro tre anni, inferiore al 2,9% di luglio; I rispondenti si aspettano un tasso di inflazione del 3% entro cinque anni, superiore al 2,9% di luglio e il livello più alto dal marzo 2022, che è l’osservazione più preoccupante di questo sondaggio.</p>
<p>Nelle ultime settimane, i funzionari della Federal Reserve hanno segnalato una nuova fase della politica monetaria, poiché sempre più evidenze suggeriscono che l’alta inflazione, che ha portato a significativi aumenti dei tassi di interesse, sta finalmente iniziando a tornare al target del 2%. Tuttavia, i funzionari mantengono comunque la prospettiva di aumentare nuovamente i tassi di interesse.</p>
<p>I funzionari della Federal Reserve sono soddisfatti delle recenti performance dell’inflazione prevista, poiché ritengono che le aspettative pubbliche di pressione sui prezzi avranno un forte impatto sul livello attuale dell’inflazione. Pertanto, le aspettative di inflazione stabile sostengono la loro visione che l’inflazione torni al suo obiettivo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>