Tm90aXppZSBxdW90aWRpYW5l772cR2xpIEVURiBCVEMgY29udGludWFubyBhIHJlZ2lzdHJhcmUgYWZmbHVzc2kgbmV0dGksIGlsIGxlYWRlciBBSSBNZW1lIEdPQVQgc3VwZXJhIGkgODAwIG1pbGlvbmkgZGkgZG9sbGFyaSBwcmltYSBkaSByaXRpcmFyc2k=

2024-10-28, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/173008776210.28.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20gli20ETF20BTC20hanno20visto20ingressi20di20oltre20400M20lo20scorso20venerd20e20TIA2020pronta20per20un20significativo20sblocco20di20token422908"><a name="Riassunto giornaliero di Crypto: gli ETF BTC hanno visto ingressi di oltre $400M lo scorso venerdì, e TIA è pronta per un significativo sblocco di token." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: gli ETF BTC hanno visto ingressi di oltre $400M lo scorso venerdì, e TIA è pronta per un significativo sblocco di token.</h2><p>Secondo i dati di Farside Investor, lo spot degli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF hanno avuto un afflusso netto di $402M venerdì scorso, di cui $292M nell’ETF IBIT di BlackRock. Il punto degli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF hanno registrato un piccolo afflusso netto di 19,2 milioni di dollari lo scorso venerdì, interamente compensato dagli deflussi dall’ETHE di Grayscale.</p>
<p><strong>Dati: <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Il TVL della rete è cresciuto di quasi il 20% la scorsa settimana, raggiungendo il suo livello più alto da gennaio 2022</strong><br>Secondo DefiLlama, il TVL della rete <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è salito a $7,403B, un aumento settimanale del 19,92%, probabilmente beneficiando della recente follia delle monete meme, raggiungendo il livello più alto dal gennaio 2022.</p>
<p><strong>Questa settimana, i token TIA, OP, SUI, IMX sono pronti per sbloccare importanti</strong><br>Secondo Tokenomist.ai, i token TIA, OP, SUI e IMX vedranno sblocchi consistenti questa settimana. Tra i punti salienti:</p>
<ul>
<li>TIA sbloccherà circa 176 milioni di token il 30 ottobre alle 20:00, rappresentando l’80,13% dell’offerta circolante attuale, del valore di circa $900M.</li><li>OP sbloccherà circa 31,34 milioni di token il 31 ottobre alle 8:00, rappresentando il 2,5% dell’offerta circolante, del valore di circa $50,15M.</li><li>SUI sbloccherà circa 64,2 milioni di token l’1 novembre alle 8:00, rappresentando il 2,32% dell’offerta circolante, del valore di circa $112M.</li><li>IMX sbloccherà circa 32,47 milioni di token l’1 novembre alle 8:00, rappresentando l’1,98% dell’offerta circolante, del valore di circa $43,52M.</li></ul>
<p><strong>Analisi: le elezioni presidenziali negli Stati Uniti potrebbero innescare una grande volatilità di mercato; gli investitori sono invitati a concentrarsi sulla strategia a lungo termine</strong><br>Gli analisti di Morgan Stanley Monica Guerra e Daniel Kohen hanno esaminato l’eventuale impatto delle elezioni presidenziali degli Stati Uniti del 2024 sul mercato. Hanno osservato segnali economici misti e crescente incertezza degli investitori, con fluttuazioni nel sentiment dei consumatori e prezzi persistentemente alti che influenzano le opinioni degli elettori, mentre gli indicatori di mercato tradizionali non offrono previsioni chiare sui risultati delle elezioni.</p>
<p>Nonostante questi fattori, Guerra e Kohen ritengono: “Sebbene gli esiti politici e i successivi cambiamenti di politica possano influenzare la redditività delle aziende, i cicli aziendali ed economici potrebbero essere più strettamente legati alle performance di mercato.” Consigliano agli investitori di concentrarsi su strategie a lungo termine anziché reagire ai cambiamenti di mercato determinati dalle elezioni.</p>
<p>Gli analisti avvertono che un risultato elettorale ritardato potrebbe aumentare la volatilità, notando: “Un ritardo nei risultati delle elezioni introduce un periodo di incertezza e speculazione, che storicamente porta ad un aumento della volatilità del mercato a breve termine.” A causa di una situazione di voto ravvicinato nei principali stati indecisi e tempi incerti per il conteggio delle schede inviate per posta, i risultati finali potrebbero richiedere giorni o addirittura settimane, causando potenzialmente significative turbolenze di mercato.</p>
<p>Guardando avanti, Guerra e Kohen spiegano: ‘A misura che l’attività della campagna si intensifica, le proposte aumentano e la battaglia per gli elettori degli stati incerti si infiamma, ci aspettiamo uno sprint finale controverso fino al giorno delle elezioni. Un evento politico o una rivelazione inaspettata, una ‘sorpresa di ottobre’, potrebbe avere un lieve impatto sulle elezioni, mentre il voto per corrispondenza e il conteggio delle fasi, combinati con l’intensa competizione, potrebbero lasciare i risultati elettorali irrisolti per un certo periodo e aumentare la volatilità del mercato.’</p>
<h2 id="h2-Analisi20di20mercato20NEIROETH20in20forte20aumento20GOAT20in20calo20dopo20aver20superato20gli2080020milioni20di20dollari358254"><a name="Analisi di mercato: NEIROETH in forte aumento, GOAT in calo dopo aver superato gli 800 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato: NEIROETH in forte aumento, GOAT in calo dopo aver superato gli 800 milioni di dollari</h2><p><strong>Evidenze di mercato</strong><br>NEIROETH è aumentato del 50%, raggiungendo una capitalizzazione di mercato di $100M. Il suo token NEIROCTO è aumentato del 7% nelle ultime 24 ore, con una capitalizzazione di mercato di $670M.</p>
<p>-SOL è rimbalzato sopra i 175$ dopo essere sceso a 160$ venerdì, facendo salire i token sul mercato <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> catena. CHAT è salito di oltre l’80% intraday, restringendosi a circa il 40% di guadagni. CHAT è un protocollo sociale sulla catena Solana, che consente comunicazioni di testo, voce e video on-chain.</p>
<ul>
<li>La moneta meme delle elezioni americane MAGA è salita oltre il 15% durante la giornata, influenzata significativamente dalla notizia dell’aumento delle probabilità di vittoria di Trump. Ad agosto, il team di MAGA ha affrontato un conflitto interno, con il fondatore che si è dimesso, lasciando il CTO responsabile della comunità.</li></ul>
<p><strong>Tendenze di mercato</strong><br>-BTC si sta consolidando sopra i $67.500, con oltre $400M di flussi ETF lo scorso venerdì, mantenendo flussi di capitale positivi.</p>
<p>-ETH si sta consolidando al di sotto di $2.500 con minime fluttuazioni, e la pressione di vendita di ETHE di Grayscale richiederà diversi mesi per risolversi.</p>
<p>-Gli altcoin sono generalmente in calo, con la criptovaluta meme GOAT su catena superando brevemente una capitalizzazione di mercato di oltre 800 milioni di dollari, anche se si tratta di picchi isolati e il sentiment di mercato rimane relativamente contenuto.</p>
<h2 id="h2-Economia20Macro20Mercato20Azionario20Statunitense20Misti20La20Scorsa20Settimana20Focus20sui20Guadagni20dei20Giganti20Tecnologici20e20sul20Rapporto20sullOccupazione620688"><a name="Economia Macro: Mercato Azionario Statunitense Misti La Scorsa Settimana, Focus sui Guadagni dei Giganti Tecnologici e sul Rapporto sull’Occupazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia Macro: Mercato Azionario Statunitense Misti La Scorsa Settimana, Focus sui Guadagni dei Giganti Tecnologici e sul Rapporto sull’Occupazione</h2><p>Lo scorso venerdì, i tre principali indici azionari statunitensi hanno mostrato tendenze miste, con l’S&amp;P 500 in calo dello 0,03% a 5808,12 punti, il Dow Jones in calo dello 0,61% a 42114,40 punti e il Nasdaq in aumento dello 0,56% a 18518,61 punti. Nella settimana scorsa, il Dow è sceso del 2,68%, il Nasdaq è salito dello 0,16% e l’S&amp;P 500 è sceso dell’0,96%. Inoltre, il rendimento del Tesoro statunitense decennale si attesta al 4,25%, con il rendimento biennale all’4,11%, quest’ultimo essendo più sensibile ai tassi di politica della Federal Reserve.</p>
<p>Il rapporto “Beige Book” della Federal Reserve della scorsa settimana ha indicato che, dall’inizio di settembre, la situazione economica complessiva degli Stati Uniti è rimasta per lo più invariata, con l’attività economica che mostra segni di debolezza nella maggior parte delle regioni.</p>
<p>Attualmente il mercato azionario americano è nella stagione dei risultati del terzo trimestre. Finora sono stati pubblicati 181 rapporti sui risultati. Si prevede che gli utili delle società americane per il terzo trimestre del 2024 cresceranno del 1,1% rispetto al trimestre precedente e del 12,9% rispetto al terzo trimestre del 2023. Si prevede che gli utili delle società americane per il 2024 cresceranno del 9,8% rispetto al 2023. Questa settimana, 94 aziende pubblicheranno rapporti sui risultati, tra cui importanti giganti tecnologici come Apple, Google, Microsoft, Amazon e ADM.</p>
<p>Il programma di pubblicazione dei dati economici statunitensi di questa settimana è il seguente: martedì (ora orientale) verranno pubblicati la bilancia commerciale dei beni negli Stati Uniti di settembre, l’indice di fiducia dei consumatori del Conference Board di ottobre e il rapporto JOLTS di settembre. Mercoledì verranno pubblicati il rapporto sull’occupazione ADP di ottobre negli Stati Uniti e i dati sul PIL del 3° trimestre. Giovedì verranno pubblicati i dati settimanali sulle richieste iniziali di disoccupazione e venerdì verrà pubblicato il rapporto sui salari non agricoli di ottobre.</p>
<div class="blog-details-info"><br><div>Autore: <strong>glassa</strong><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>