Tm90aXppZSBxdW90aWRpYW5lIHwgR2xpIEVURiBCaXRjb2luIFNwb3QgcG90cmViYmVybyBlc3NlcmUgYXBwcm92YXRpIG5lbCBwcm9zc2ltbyBnZW5uYWlvOyBsJ0luZGlhIHNpIHRyb3ZhIGluIHVuYSBwb3NpemlvbmUgZGkgcHJpbW8gcGlhbm8gbmVsIHNldHRvcmUgZGVsbGUgY3JpcHRvdmFsdXRlOyBDWUJFUiwgQVBFIGUgUk9TRSB

2023-11-13, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/16998562121_13.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Sei20previsioni20di20Matrixport20sul20mercato20delle20criptovalute20quattro20token20sbloccati20in20grandi20quantit20questa20settimana136153"><a name="Crypto Daily Digest: Sei previsioni di Matrixport sul mercato delle criptovalute, quattro token sbloccati in grandi quantità questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Sei previsioni di Matrixport sul mercato delle criptovalute, quattro token sbloccati in grandi quantità questa settimana</h2><p>L’analista di Matrixport Markus Thielen ha rilasciato sei previsioni per il mercato crittografico nella prima metà del 2024, vale a dire l’approvazione degli ETF spot di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> da parte della Securities and Exchange Commission (SEC) degli Stati Uniti a gennaio, la possibilità di quotazione di Circle in aprile, FTX 2.0 che inizierà le operazioni a maggio o giugno e il ripristino della sua posizione come uno dei primi tre scambi entro 12 mesi, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Piano di aggiornamento EIP-4844 da attuare nel primo trimestre del 2024, e il primo taglio dei tassi da parte della Federal Reserve a giugno.</p>
<p>Andrei Grachev, co-fondatore di DWF-Labs, ha dichiarato in un post che l’indice CMC è passato dalla paura a una quasi estrema avidità in soli 30 giorni. Il mercato si sente molte buone aspettative e quasi nessuna minaccia. Ma fate attenzione quando si utilizza una leva multipla, il mercato è ancora instabile, ma se state costruendo e finanziando, questo è il momento migliore.</p>
<p>Grachev ha anche aggiunto che il volume di trading è raddoppiato, l’attività di trading si sta riprendendo e la liquidità sta aumentando. È importante sottolineare che questo è guidato dagli investitori al dettaglio, non dagli operatori algoritmici, come possiamo vedere che diverse Altcoin hanno registrato un forte aumento questa settimana. Questi sono tutti segni di ripresa. Anche se non è ancora la stagione delle Altcoin, le persone stanno già speculando.</p>
<p>Secondo Bitcoin News, Michael Saylor, co-fondatore di MicroStrategy, ha recentemente dato una panoramica esaustiva sulla futura traiettoria di sviluppo di BTC alla Conferenza Australiana sulle Criptovalute del 2023. Ha parlato della riduzione a metà di BTC nel 2024 e ha previsto che il prossimo anno sarà cruciale per BTC, in quanto diventerà un “asset di base durante l’adolescenza” entro la fine dell’anno prossimo.</p>
<p>Guardando avanti al 2024-2028, Saylor prevede che BTC entrerà in una fase di forte crescita, ed è previsto che grandi industrie tecnologiche e banche di tutto il mondo adotteranno ampiamente BTC e lo integreranno nei loro rispettivi prodotti e servizi.</p>
<p>Inoltre, ha sottolineato che importanti istituzioni finanziarie come JPMorgan Chase, Morgan Stanley, Goldman Sachs, Bank of America e Deutsche Bank potrebbero essere coinvolte in attività come l’emissione di prestiti, la fornitura di garanzie, la personalizzazione e l’acquisto e la vendita di Bitcoin.</p>
<p>Da una prospettiva a lungo termine di circa 25 anni, Saylor predice che BTC dominerà tutti gli asset di alta qualità e sottolinea il suo potenziale per superare la crescita dell’indice S&amp;P 500 e dei portafogli di investimento diversificati.</p>
<p>Secondo le notizie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La senatrice statunitense Cynthia Lummis ha difeso le criptovalute e si è opposta all’affermazione secondo cui la classe di attività veniva ampiamente utilizzata per finanziamenti illegali. La senatrice ha sottolineato che “le criptovalute non sono un problema, ci sono cattivi attori in ogni settore”, Cynthia Lummis ha sottolineato che le criptovalute rappresentano meno dell’1% di tutte le attività finanziarie illegali. Inoltre, ha anche esortato il Congresso a stabilire un quadro normativo che consenta alle società di criptovalute di operare negli Stati Uniti, anziché spingerle verso “mercati esteri non regolamentati”.</p>
<p>Secondo il rapporto 2023 Global Cryptocurrency Adoption Index rilasciato dalla piattaforma di analisi blockchain Chainalysis, l’India si classifica al primo posto per l’adozione di criptovalute. Questo indice compare nel rapporto annuale di Chainalysis “Cryptocurrency Geography”, valutando specificamente l’adozione delle criptovalute da parte della popolazione generale, anziché concentrarsi esclusivamente sul volume delle transazioni. L’India si posiziona più in alto nell’indice rispetto ad altri paesi con livelli più elevati di trading e attività di mining di criptovalute.</p>
<p>Inoltre, in base al valore stimato originale delle criptovalute ricevute tra luglio 2022 e giugno 2023, l’India si è classificata al secondo posto tra i paesi più quotati. Secondo il rapporto di Chainalysis, nell’ultimo anno l’India ha ricevuto circa 250 miliardi di dollari di valore di criptovalute, secondo solo agli Stati Uniti, che hanno ricevuto circa 1 trilione di dollari di valore di criptovalute nello stesso periodo.</p>
<p>L’India si posiziona al primo posto nelle classifiche degli indici completi, delle classifiche del valore dei servizi centralizzati, delle classifiche del valore dei servizi centralizzati al dettaglio e delle classifiche del valore di DeFi, ma al quinto posto nelle classifiche del volume di scambio P2P. A seguire l’India si trovano Nigeria, Vietnam, Stati Uniti, Ucraina, Filippine e Indonesia.</p>
<p>Questa settimana, CYBER, APE e ROSE riceveranno uno sblocco unico di token, con un valore totale di rilascio di oltre $48 milioni. Tra di essi:</p>
<p>Alle 2:14 di mattina (UTC) del 15 novembre, CyberConnect sbloccherà 1,26 milioni di CYBERs (circa $8,34 milioni), corrispondenti all’11,43% dell’offerta di circolazione;</p>
<p>Alle 8:00 (UTC) del 16 novembre, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> sbloccherà 2,6 milioni di <a href="/price/flow-flow" target="_blank" class="blog_inner_link">FLOW</a> (circa 1,81 milioni di dollari), pari al 0,25% dell’offerta circolante;</p>
<p>Alle 8:00 (UTC) del 17 novembre, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> sbloccherà 15,6 milioni di APE (circa 23,25 milioni di dollari), pari al 4,23% dell’offerta circolante;</p>
<p>Alle 12:00 (UTC) del 19 novembre, <a href="/price/oasis-network-rose" rel="nofollow noopener noreferrer" target="_blank">Oasis Network</a> sbloccherà 196 milioni di ROSE (circa $14,5 milioni), corrispondenti al 3,9% della fornitura circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi387318"><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-BTC753089"><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/169985642314501699856352_.pic.jpg" alt=""><br>La scorsa settimana, BTC ha chiuso a quota $37.000 USD. Questa settimana ha aperto con un’andamento altalenante e piatto, senza mostrare tendenze significative. Si prevede che continui a declinare gradualmente fino al supporto di $36.000 USD e che incontri resistenza a $37.755 USD. La tendenza settimanale potrebbe scendere al minimo di $32.850 USD.</p>
<h3 id="h3-ETH424383"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/169985644714511699856374_.pic_hd.jpg" alt=""><br>Il grafico giornaliero cerca di superare la resistenza di $2.135 USD, raggiungendo un punto relativamente alto in un anno e mezzo. Il consiglio a breve termine è di mantenere la posizione a $2.037 USD. Se avrà successo, è previsto di superare i $2.135 USD e raggiungere i $2.381 USD. Inoltre, c’è la possibilità di seguire il trend mantenendo la posizione a $2.045 USD.</p>
<h3 id="h3-FTT16510"><a name="FTT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTT</h3><p><img src="https://gimg2.gateimg.com/image/article/169985647214521699856394_.pic.jpg" alt=""><br>Il trend complessivo da $1.3965 USD a $1.56 USD è salito fino a toccare un massimo di $5 USD. Il supporto a breve termine è a $3.21 USD e la resistenza deve rompere costantemente i $4.92 USD per puntare a $6.49 USD e $11.04 USD.</p>
<h2 id="h2-Macro20Moodys20valuta20gli20Stati20Uniti20come20negativi20attenzione20ai20dati20CPI20questa20settimana130634"><a name="Macro: Moody’s valuta gli Stati Uniti come negativi, attenzione ai dati CPI questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Moody’s valuta gli Stati Uniti come negativi, attenzione ai dati CPI questa settimana</h2><p>La settimana scorsa, il discorso del presidente della Federal Reserve Powell ha ribaltato con forza la precedente “valutazione accomodante” nel mercato e ha fatto precipitare nuovamente il mercato nel “caos falco”. Il dollaro statunitense forte ha registrato la sua migliore performance settimanale da agosto, l’oro è tornato vicino al livello di $1.930 e l’asta di obbligazioni statunitensi a 30 anni ha suonato un allarme di liquidità.</p>
<p>Moody’s, l’unica delle tre principali società di rating al mondo a mantenere il massimo rating sovrano degli Stati Uniti, ha anche annunciato dopo la chiusura del mercato azionario statunitense lo scorso venerdì che manterrà il suo rating di investimento più alto Aaa ma modificherà il suo outlook da stabile a negativo. La principale considerazione di Moody’s per prendere questa decisione è l’alto tasso di interesse negli Stati Uniti combinato con un enorme deficit fiscale, unito alla attuale situazione di negoziazione reciproca in Congresso.</p>
<p>Nella nuova settimana, i dati sull’indice dei prezzi al consumo e i dati di “panico” andranno di pari passo e il conflitto israelo-palestinese continua a turbare i nervi dei trader. Anche la “chiusura” del governo degli Stati Uniti si avvicina.</p>
<p>La Federal Reserve ha mantenuto il suo tasso di interesse di riferimento al massimo in 22 anni dopo la sua riunione di novembre.</p>
<p>A causa del deludente rapporto sull’occupazione negli Stati Uniti, il dollaro statunitense ha subito un forte colpo. La scorsa settimana, diversi funzionari della Federal Reserve hanno sottolineato che l’eccellente performance dell’economia statunitense ha aperto la porta a ulteriori aumenti dei tassi di interesse, e vi è stata una debole ripresa del dollaro statunitense. Proprio lo scorso giovedì, il presidente della Federal Reserve Powell ha dichiarato che i funzionari “non credono” che i tassi di interesse siano abbastanza alti per indicare la fine della lotta contro l’inflazione.</p>
<p>Powell ha dichiarato in un discorso al Fondo Monetario Internazionale (FMI) giovedì che per ridurre l’inflazione al 2%, potrebbero essere necessarie ulteriori misure di restrizione. Il mercato interpreta le osservazioni di Powell come hawkish, cambiando il tono dovish che ha espresso nell’ultimo incontro di politica della scorsa settimana.</p>
<p>Tuttavia, gli investitori ancora in gran parte non credono che la Federal Reserve possa aumentare nuovamente i tassi di interesse. Secondo i futures sui fondi federali, credono che ci sia solo una probabilità del 20% di un ultimo aumento dei tassi di 25 punti base entro gennaio prossimo, e si aspettano una riduzione dei tassi di circa 80 punti base entro la fine dell’anno prossimo.</p>
<p>Forse è perché ci sono ancora molti membri con una posizione accomodante all’interno della Federal Reserve, oppure forse i partecipanti al mercato si aspettano che l’inflazione diminuisca nuovamente, specialmente dopo la caduta dei prezzi del petrolio in ottobre, quando l’economia continuerà a indebolirsi.</p>
<p>In effetti, il modello GDPNow della Fed di Atlanta stima che il tasso di crescita annuale degli Stati Uniti nel quarto trimestre sia stato del 2,1%, il che sembra normale in un ambiente di tassi di interesse elevati e un’accelerazione dell’economia statunitense al 4,9% nel terzo trimestre.</p>
<p>Dato tutto ciò, l’attenzione di questa settimana potrebbe spostarsi sui dati CPI di ottobre degli Stati Uniti, pubblicati martedì, che potrebbero essere una relazione chiave per determinare se la Federal Reserve prenderà provvedimenti a dicembre.</p>
<p>Si prevede che il tasso di crescita anno su anno dell’indice dei prezzi al consumo complessivo scenderà dal 3,7% al 3,3%, e il tasso di crescita anno su anno dell’indice dei prezzi al consumo di base scenderà dal 4,1% al 4,0%. Inoltre, considerando che il PMI di ottobre ha mostrato una diminuzione della pressione sui prezzi, il rischio di inflazione potrebbe tendere a diminuire, e poiché il cambiamento anno su anno dei prezzi del petrolio diventa nuovamente negativo, l’inflazione complessiva potrebbe continuare a indebolirsi prima della fine dell’anno.</p>
<p>Sebbene il CPI core stia ancora rallentando a un tasso stabile, l’inflazione complessiva negli Stati Uniti è aumentata leggermente negli ultimi tre mesi. A settembre, il CPI core negli Stati Uniti è diminuito dal 4,3% al 4,1%, principalmente a causa della leggera aumento dei prezzi degli affitti e dei carburanti. Ciò ha effettivamente sollevato preoccupazioni che la Federal Reserve sia probabilmente destinata ad aumentare i tassi di interesse di nuovo tra ora e la fine dell’anno.</p>
<p>Per i funzionari della Federal Reserve che sono apparsi questa settimana, il presidente della Fed di Chicago Goolsby va senza dire che è un deciso “colombino”, mentre il presidente della Fed di New York Williams è l’”alleato deciso” di Powell e si prevede che ribadirà alcune delle opinioni espresse da Powell giovedì. Si prevede che il presidente della Fed di Boston Collins e il presidente della Fed di San Francisco Daley continuino a ribadire le aspettative “più alte e più lunghe” della Fed.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>