Tm90aXppZSBnaW9ybmFsaWVyZSB8IFNVSSBoYSByYWdnaXVudG8gdW4gbnVvdm8gbWFzc2ltbyBzdG9yaWNvLCBpIHRyYWRlciBiYWxlbm90dGVyaSBkaSBORUlST0VUSCBzb25vIGF1bWVudGF0aQ==

2024-10-14, 04:16

<p><img src="https://gimg2.gateimg.com/image/article/172887920510.14.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20cripto20NEIROETH20ha20visto20un20significativo20aumento20dei20detentori20e20ARB20dar20il20benvenuto20ad20un20grande20sblocco380022"><a name="Riassunto giornaliero cripto: NEIROETH ha visto un significativo aumento dei detentori, e ARB darà il benvenuto ad un grande sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero cripto: NEIROETH ha visto un significativo aumento dei detentori, e ARB darà il benvenuto ad un grande sblocco</h2><p>Secondo i dati degli investitori di Farside, c’è stato un ingresso netto di 253 milioni di dollari nel mercato spot degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ETF lo scorso venerdì, tra cui 117 milioni di dollari da Fidelity FBTC, 97,6 milioni di dollari da ARKB e nessun afflusso o deflusso di fondi da BlackRock IBIT.</p>
<p>Venerdì scorso, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF ha avuto un deflusso netto di $100.000, con $8,6 milioni da Fidelity FETH e $8,7 milioni da Grayscale GBTC.</p>
<p><strong>Se <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> se scende al di sotto dei 61.000 dollari, la forza cumulativa di liquidazione degli ordini CEX principali raggiungerà i 653 milioni</strong></p>
<p>Secondo i dati di Coinglass, se <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> scende sotto i 61.000 dollari, la forza di liquidazione cumulativa degli ordini CEX mainstream raggiungerà i 653 milioni; Al contrario, se Bitcoin supera i 64.000 dollari, la forza di liquidazione cumulativa degli ordini short CEX mainstream raggiungerà gli 848 milioni.</p>
<p>Il grafico di liquidazione non mostra il numero esatto di contratti da liquidare o il loro valore preciso. Le colonne sul grafico di compensazione mostrano l’importanza, cioè la forza, di ciascun cluster di compensazione rispetto ai cluster di compensazione vicini.</p>
<p>Pertanto, il grafico di liquidazione mostra in che misura il prezzo target sarà influenzato quando raggiunge una certa posizione. Una “colonna di liquidazione” più alta indica che il prezzo avrà una reazione più forte a causa dell’ondata di liquidità una volta arrivata.</p>
<p><strong>ARB, AXS e altri token riceveranno uno sblocco su larga scala, del valore di circa $220 milioni, una tantum</strong></p>
<p>Secondo i dati di Token Unlocks, ARB, AXS e altri token riceveranno sbloccaggi significativi la prossima settimana, per un valore di circa 220 milioni di dollari. Tra di essi:</p>
<p>Arbitrarum (ARB) sbloccherà circa 92,65 milioni di token alle ore 21:00 ora di Pechino del 16 ottobre, con un rapporto del 2,56% rispetto all’attuale <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> e un valore di circa $49.4 milioni;</p>
<p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> (AXS) sbloccherà circa 9,25 milioni di token alle 21:10 ora di Pechino del 14 ottobre, con un rapporto di flusso corrente del 6,08% e un valore di circa $43,1 milioni;</p>
<p>Eigenlayer (EIGEN) sbloccherà circa 11,22 milioni di token alle 3 del mattino, ora di Pechino, il 16 ottobre, rappresentando il 6,01% del flusso attuale e circa 43,9 milioni di dollari di valore.</p>
<p><strong>Recentemente è aumentata l’attività delle balene NEIROETH, con GSR che attualmente detiene il 4,04% dell’offerta totale di token</strong></p>
<p>Secondo il monitoraggio di Spot On Chain, Neiro su ETH (NEIROETH sul sito di Gate) sembra essere uscito dalla fase di accumulazione e le balene sono diventate più attive, con acquirenti tra cui GSR Markets, che attualmente detengono 40,4 milioni di NEIROETH, pari al 4,04% dell’offerta totale. L’ultimo aumento delle detenzioni è stato due giorni fa; Smart Money 0xe9f ha venduto OM e ATH del valore di 1 milione di dollari 3 ore fa, scambiandoli per il primo lotto di 8,45 milioni di monete; bwecapital.eth ha accumulato 4,065 milioni di monete due giorni fa, pari allo 0,4% dell’offerta circolante;</p>
<p>Gli venditori includono entità che hanno guadagnato $145 milioni da SHIB e venduto 17,5 milioni di unità cinque giorni fa, con una perdita di $1,49 milioni (-55%); Whale 0x00D ha depositato 4,7 milioni di monete ($531.000) in CEX nelle ultime 17 ore, guadagnando $247.000 (+87%).</p>
<h2 id="h2-Tendenze20di20mercato20SUI20ha20raggiunto20un20massimo20storico20i20fan20token20sono20aumentati20collettivamente650307"><a name="Tendenze di mercato: SUI ha raggiunto un massimo storico, i fan token sono aumentati collettivamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: SUI ha raggiunto un massimo storico, i fan token sono aumentati collettivamente</h2><h3 id="h3-Punti20Caldi20del20Mercato513181"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>SUI ha superato i $2,2, continuando a stabilire un nuovo massimo storico, con nuovi progetti di catena pubblica come APT e TIA che seguono l’esempio. SUI è il token principale nel settore della catena pubblica in questa fase delle tendenze di mercato, con una classifica complessiva della capitalizzazione di mercato tra le prime 20;</p>
<p>L’aumento dei token per i fan come CHZ, OG e PSG, e l’aumento collettivo dei token per i fan spesso indica la fine della tendenza di mercato a breve termine e potrebbe presto entrare in una zona di correzione;</p>
<p>BOME è salito di oltre il 10%, trainando gli altri <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> su progetti meme on chain come MANKEI e PENG per fare altrettanto.</p>
<h3 id="h3-Monete20principali506019"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è ancora volatile tra i $60.000 e i $66.000, e il prezzo si trova attualmente al centro delle Bollinger Bands. Questa settimana è un periodo critico per la tendenza futura dei prezzi di BTC;</p>
<p>Le prestazioni di ETH sono deboli, con un volume di trading di ETH ETF e afflussi di fondi molto al di sotto delle aspettative, e la volatilità settimanale di ETH è inferiore al 10%;</p>
<p>Le altcoin sono generalmente diminuite, con i principali token come POPCAT e FTM che hanno subito un ritracciamento in precedenza, e attualmente non ci sono altri progetti leader sul mercato.</p>
<h2 id="h2-Macroeconomia20La20borsa20valori20statunitense20ha20chiuso20in20rialzo20venerd20scorso20e20la20probabilit20che20la20Fed20tagli20i20tassi20di20interesse20di202520punti20base20a20novembre2020aumentata20significativamente449739"><a name="Macroeconomia: La borsa valori statunitense ha chiuso in rialzo venerdì scorso e la probabilità che la Fed tagli i tassi di interesse di 25 punti base a novembre è aumentata significativamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: La borsa valori statunitense ha chiuso in rialzo venerdì scorso e la probabilità che la Fed tagli i tassi di interesse di 25 punti base a novembre è aumentata significativamente</h2><p>I tre principali indici azionari statunitensi hanno chiuso in rialzo, con l’indice S&amp;P 500 che è salito dello 0,61% a 5.815,03 punti; il Dow Jones Industrial Average è salito dello 0,97% a 42.863,86 punti; l’indice Nasdaq è salito dello 0,33% a 18.342,94 punti. La scorsa settimana, l’indice Dow Jones è salito del 1,21%, l’indice Nasdaq è salito dell’1,13% e l’indice S&amp;P 500 è salito dell’1,11%. Il rendimento del titolo di Stato decennale di riferimento è del 4,08%, mentre il rendimento del titolo di Stato biennale, più sensibile alla politica dei tassi della Federal Reserve, è del 3,95%.</p>
<p>I verbali della riunione di settembre della Federal Reserve, pubblicati la scorsa settimana, hanno mostrato una maggiore divergenza nella portata del taglio dei tassi. Sebbene Powell abbia guidato il voto quasi all’unanimità a favore di un taglio dei tassi di 50 punti base, non solo il governatore Bauman ha sostenuto un taglio dei tassi di 25 punti base, ma anche altri funzionari ritenevano che la normalizzazione della politica dovesse essere graduale.</p>
<p>Giovedì, i dati hanno mostrato che l’indice dei prezzi al consumo (CPI) degli Stati Uniti per settembre è aumentato del 2,4% su base annua e dello 0,2% su base mensile; L’indice CPI core è aumentato del 3,3% su base annua e dello 0,3% su base mensile, entrambi superando le aspettative di mercato. Dal focus sull’inflazione dei servizi super core da parte del presidente della Federal Reserve, Powell, i tassi di crescita su base annua e su base mensile a settembre sono diminuiti dello 0,02%. Sono aumentati rispettivamente dello 0,06% rispetto ad agosto, con tassi di crescita su base mensile in aumento per tre mesi consecutivi.</p>
<p>I dati mostrano che il processo anti-inflazione negli Stati Uniti sta cominciando a rallentare e il rischio precedentemente temuto di un rimbalzo dell’inflazione core è in crescita. Ciò potrebbe avere un impatto significativo sul ritmo e sull’entità dei successivi tagli dei tassi di interesse. Dopo la pubblicazione dei dati, i trader hanno scommesso che la probabilità che la Federal Reserve tagli i tassi di interesse di 25 punti base a novembre è superiore all’80%.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa</strong>, Ricercatore 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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>