Tm90aXppZSBxdW90aWRpYW5lIHwgR0JUQyBzdXBlcmEgTlZJRElBLCBjb24gdW4gdGFzc28gZGkgY3Jlc2NpdGEgZGVsIDIyMCUgcXVlc3QnYW5ubzsgTCdhZ2dpb3JuYW1lbnRvIGRpIEV0aGVyZXVtIERlbmNodW4gcG90cmViYmUgZXNzZXJlIHBvc3RpY2lwYXRvIGZpbm8gYWxsJ2Fubm8gcHJvc3NpbW8=

2023-10-27, 04:46

<p><img src="https://gimg2.gateimg.com/image/article/16983855961027.jpg" alt=""></p>
<h2 id="h2-Riassunto20criptovalute20quotidiano20GBTC20ha20superato20NVIDIA20con20un20tasso20di20crescita20del2022020questanno20laggiornamento20Ethereum20Denchun20potrebbe20essere20posticipato20fino20allanno20prossimo39886"><a name="Riassunto criptovalute quotidiano: GBTC ha superato NVIDIA, con un tasso di crescita del 220% quest’anno; l’aggiornamento Ethereum Denchun potrebbe essere posticipato fino all’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto criptovalute quotidiano: GBTC ha superato NVIDIA, con un tasso di crescita del 220% quest’anno; l’aggiornamento <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Denchun potrebbe essere posticipato fino all’anno prossimo</h2><p>Secondo i dati di TradeView, il prezzo delle azioni di GBTC è aumentato del 220% quest’anno a $26.79.</p>
<p>Nel frattempo, NVDA, la migliore azione del S&amp;P 500, è salita del 198%, mentre l’indice S&amp;P 500 è salito del 9%. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è raddoppiato quest’anno a $35000. Inoltre, a causa di un sentimento ottimista, il tasso di premio negativo di GBTC si è ridotto dal 46% al 13%, indicando un mercato rialzista.</p>
<p>JPMorgan Chase ha dichiarato in un rapporto di ricerca mercoledì che <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> La notizia sull’approvazione da parte della SEC degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot continua a crescere. Il rapporto afferma che questo ottimismo si riflette nelle solide prestazioni del Bitcoin rispetto ad altri asset digitali e sottolinea che il Bitcoin ha recentemente raggiunto un nuovo massimo per l’anno. Gli analisti guidati da Nikolaos Panigrtzoglou hanno scritto: “Sembra che l’attuale flusso di capitali abbia coinvolgimento istituzionale”.</p>
<p>Gli analisti hanno detto: ‘La nostra posizione a termine proxy basata sui futures del Bitcoin del CME (spesso utilizzata principalmente dagli investitori istituzionali) è schizzata alle stelle nella scorsa settimana, non solo raggiungendo un massimo annuale ma anche raggiungendo livelli precedenti al crollo del FTX nell’agosto 2022’. Nel frattempo, il proxy equivalente per la posizione a termine del CME <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures rimane debole.</p>
<p>Il rapporto afferma che la partecipazione delle istituzioni nel recente rimbalzo è anche riflessa nell’analisi del traffico in Bitcoin. Una grande quantità di Bitcoin è fluita in indirizzi di portafoglio più grandi, indicando la domanda da parte degli investitori istituzionali. Il rapporto evidenzia che ciò è in netto contrasto con i trimestri precedenti, “quando gli afflussi di Bitcoin erano dominati da portafogli più piccoli e quindi guidati maggiormente dagli investitori al dettaglio.”</p>
<p>Il 26 ottobre, l’ultimo rapporto di Matrixport mostra che il quinto mercato toro di Bitcoin è ufficialmente iniziato il 22 giugno 2023, e Bitcoin ha raggiunto un nuovo massimo per la prima volta in un anno. Da un punto di vista storico, quando viene attivato questo segnale, il rendimento medio di Bitcoin è del +310%.</p>
<p>Sulla base di questo segnale, Matrixport prevede che Bitcoin potrebbe raggiungere i 125.000$ entro dicembre 2024. Il rapporto sottolinea che questo mercato rialzista è guidato principalmente dalle aspettative di adozione istituzionale. Le caratteristiche di Bitcoin sono state tradizionalmente legate ad asset come l’oro e altri investimenti rifugio come i buoni del tesoro, il che ha portato le istituzioni a prendere in considerazione l’utilizzo di Bitcoin per diversificare la loro asset allocation. Non è un caso che Bitcoin sia salito alle stelle quando il rapporto tra debito USA e PIL ha raggiunto un livello insostenibile.</p>
<p>Il 27 ottobre, gli sviluppatori del client Ethereum hanno confermato giovedì che l’atteso aggiornamento Denchun non verrà implementato nella hard fork della rete prima della fine del 2023. Il developer Prysm anonimo, Potuz, ha confermato durante la conference call odierna degli sviluppatori principali che non sarà possibile eseguire il fork della mainnet nel 2023.</p>
<p>Ha sottolineato che nei mesi scorsi ci sono stati problemi di consenso tra le 10 reti di sviluppatori che hanno iniziato i test e l’aggiornamento, e “nessuna di esse ha progredito senza intoppi.” Il mese scorso, con il lancio della rete di test Ethereum Holesky prevista in ritardo, si è unanimemente ritenuto che ci fosse poco possibilità di completare l’aggiornamento Denchun prima di dicembre.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi452704"><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-BTC915204"><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/1698385627btc.png" alt=""><br>L’alto di questa settimana a $36.000 probabilmente ha raggiunto il suo picco, segnando un top di fase a breve termine. Siate cauti di un potenziale mercato ad ago alto, il che significa una rapida salita a $36.000 seguita da una rapida caduta al livello di $33.000. Nel medio termine, ci aspettiamo ancora un supporto intorno a $37.700.</p>
<p>Dopo aver raggiunto il picco, ci si aspetta una fase di declino, quindi entrare al prezzo attuale è considerato inseguire il prezzo, il che comporta un profitto a breve termine ma potrebbe comportare rischi a lungo termine. Se si attende un secondo calo, continuare a monitorare lo spazio intorno a $32.500 e $30.800 per un possibile ritracciamento.</p>
<h3 id="h3-ETH315383"><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/1698385645Eth.png" alt=""><br>Il massimo di questa settimana ha toccato il livello di $ 1.857, un punto critico sia per le tendenze rialziste che per quelle ribassiste. È essenziale notare che si è formato un pattern “M” ribassista e si consiglia di mantenersi stabili a 1.754$. Una violazione di questo livello potrebbe portare a ulteriori cali verso $ 1.726 e $ 1.694. Nel complesso, il volume suggerisce un sentimento ribassista nel mercato.</p>
<h3 id="h3-RACA514161"><a name="RACA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RACA</h3><p><img src="https://gimg2.gateimg.com/image/article/1698385662Raca.png" alt=""><br>Il settore dei giochi blockchain è in crescita di nuovo, con posizioni suggerite a due livelli chiave: $0.00014, che potrebbe continuare a salire fino a $0.00017 e $0.000195. C’è ancora spazio per guadagni a breve termine e, se si entra in questo intervallo, si consiglia di entrare ed uscire rapidamente o utilizzare una strategia di stop-loss iniziale per puntare a $0.00029.</p>
<h2 id="h2-Macro20Si20prevede20che20la20Fed20mantenga20i20tassi20di20interesse20in20novembre20e20si20prevede20di20ottenere20un20atterraggio20morbido20per20leconomia475280"><a name="Macro: Si prevede che la Fed mantenga i tassi di interesse in novembre e si prevede di ottenere un atterraggio morbido per l’economia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Si prevede che la Fed mantenga i tassi di interesse in novembre e si prevede di ottenere un atterraggio morbido per l’economia</h2><p>Il 26 ottobre, l’economia degli Stati Uniti è cresciuta al suo ritmo più veloce da quasi due anni nel terzo trimestre, poiché i mercati del lavoro stretti hanno portato ad aumenti salariali, contribuendo a stimolare la spesa dei consumatori. L’economia degli Stati Uniti ha nuovamente ignorato l’avvertimento persistente di recessione economica dal 2022. Secondo i dati del Dipartimento del Commercio degli Stati Uniti, il tasso di crescita trimestrale del PIL nel terzo trimestre degli Stati Uniti è stato del 4,9%, il tasso di crescita più veloce dal quarto trimestre del 2021.</p>
<p>Anche se è improbabile che questo forte crescita economica continui, dimostra la resilienza dell’economia. A causa dello sciopero della UAW e del fatto che milioni di americani riprendono a rimborsare i prestiti studenteschi, la crescita negli Stati Uniti potrebbe rallentare nel quarto trimestre. La maggior parte degli economisti ha rivisto le proprie previsioni, ritenendo che la Federal Reserve possa ottenere un “atterraggio morbido” per l’economia. I mercati finanziari si aspettano che la Federal Reserve mantenga i tassi di interesse invariati a novembre.</p>
<p>L’oro spot è salito prima e poi è sceso, raggiungendo un massimo intraday di $1.993,52 durante la sessione di trading europea, ma poi è leggermente diminuito, chiudendo infine in rialzo dello 0,26% a $1.984,74 per oncia; l’argento spot non è riuscito a stabilizzarsi sopra i $23 e alla fine ha chiuso in ribasso dello 0,3% a $22,79 per oncia.</p>
<p>I tre principali indici azionari statunitensi hanno continuato a diminuire a causa del peso delle grandi società tecnologiche, con il Dow che ha chiuso in calo dello 0,76%, il Nasdaq con una diminuzione del 1,76% e l’indice S&amp;P 500 che ha chiuso in calo del 1,18%.</p>
<p>L’Iran ha annunciato che organizzerà esercitazioni militari in futuro prossimo. Il ministro degli esteri iraniano ha dichiarato che non vogliono che il conflitto si intensifichi. Hamas è pronta a rilasciare prigionieri civili e chiede a Israele di rilasciare 6.000 palestinesi. Israele ha dichiarato che continuerà a effettuare limitati attacchi terrestri sulla Striscia di Gaza. Gli Stati Uniti stanno inviando ulteriori 900 soldati in Medio Oriente.</p>
<p>Non ci sono molte informazioni a livello macro e il conflitto israelo-palestinese continua ad intensificarsi. Ieri, le truppe a <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> di Kishleb sono entrate nell’area di Gaza di notte per effettuare un raid su alcune infrastrutture, per poi ritirarsi immediatamente dall’area di Gaza. Il Ministero della Difesa israeliano ha dichiarato che ciò è stato fatto in preparazione di futuri combattimenti terrestri.</p>
<p>Nel frattempo, nove paesi arabi, tra cui gli Emirati Arabi Uniti, la Giordania, il Bahrain, l’Arabia Saudita, l’Oman, il Qatar, il Kuwait, l’Egitto e il Marocco, hanno emesso una dichiarazione congiunta condannando l’uccisione di civili da parte di Israele nella Striscia di Gaza, affermando che “la legittima difesa non può essere un motivo per violare il diritto internazionale e ignorare deliberatamente i legittimi diritti del popolo palestinese.” Hanno inoltre accusato Israele di attuare una “punizione collettiva” contro i palestinesi, che ha portato allo spostamento forzato dei palestinesi.</p>
<p>Con l’intensificarsi dei conflitti geopolitici, l’oro è brevemente salito a 2000 punti. Recentemente, asset come l’oro, rifugio sicuro, e Bitcoin non hanno seguito le fluttuazioni delle azioni statunitensi. Pertanto, per gli investitori, gli asset con attributi di rifugio sicuro devono essere obiettivi di alta qualità per un lungo periodo di tempo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttrice: 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 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>