Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGhhIGd1aWRhdG8gaWwgbWVyY2F0byB2ZXJzbyB1biBzaWduaWZpY2F0aXZvIHJpbWJhbHpvLCBGVE0gZSBQRU9QTEUgc2kgc29ubyBjb21wb3J0YXRpIGluIG1vZG8gZWNjZXppb25hbGU=

2024-09-10, 04:54

<p><img src="https://gimg2.gateimg.com/image/article/17259439039.10.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20la20dominanza20del20BTC20potrebbe20raggiungere20il20picco20BlackRock20IBIT20raramente20ha20avuto20deflussi3439"><a name="Riassunto giornaliero delle criptovalute: la dominanza del BTC potrebbe raggiungere il picco, BlackRock IBIT raramente ha avuto deflussi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: la dominanza del BTC potrebbe raggiungere il picco, BlackRock IBIT raramente ha avuto deflussi</h2><p>Secondo i dati di Farside Investor, c’è stato un piccolo afflusso di 25 milioni di dollari negli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot ieri. Tra questi, BlackRock IBIT ha avuto un deflusso netto di $8.99 milioni, Fidelity FBTC ha avuto un afflusso netto di $28 milioni, e Grayscale GBTC ha avuto un deflusso netto di $22.8 milioni.</p>
<p>Ieri il volume complessivo degli scambi spot statunitensi <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF è stato estremamente basso, con un deflusso complessivo di 5,2 milioni di dollari. Tra questi, il deflusso di grayscale ETHE è stato di 22,6 milioni di dollari, e l’afflusso netto di Fidelity FETH è stato di 7,6 milioni di dollari.</p>
<p><strong>Rapporto: Se la posizione dominante del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> raggiunge il picco, gli Altcoin supereranno il BTC nei prossimi mesi</strong></p>
<p>Bitcoin è sceso del 10,7% nella prima settimana di settembre, continuando il suo trend al ribasso da fine agosto. Tuttavia, questo calo ha spinto anche il prezzo al di sotto del livello critico di $56.711, che era comparso anche il 1° maggio e aveva precedentemente innescato un rapido rimbalzo. Come previsto, questa vendita ha portato a una diminuzione delle posizioni leva, indicando che il mercato potrebbe avvicinarsi a un minimo locale. È interessante notare che dal 27 agosto gli ETF Bitcoin hanno registrato un deflusso netto di $706,1 milioni, mentre la differenza cumulativa del volume di trading spot mostra un trend al ribasso, indicando una grande quantità di vendite spot.</p>
<p>Al contrario, il mercato delle altcoin ha mostrato resilienza. Durante la vendita di Bitcoin della scorsa settimana, la proporzione del valore di mercato di Bitcoin (misurando il suo valore di mercato relativo al resto del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a>) è diminuito del 1,3%. Al contrario, il valore di mercato delle altre criptovalute (escludendo le prime 10 valute) è aumentato del 4,4%. Si può dire che questo cambiamento implichi un possibile cambiamento nel panorama di mercato, dove gli investitori cercano valore nelle altcoin anziché continuare ad affluire verso Bitcoin durante una fase di ribasso.</p>
<p>Tuttavia, se la posizione dominante del Bitcoin ha effettivamente raggiunto un massimo locale, potremmo vedere le Altcoins performare meglio del Bitcoin nei prossimi mesi, il che potrebbe gettare le basi per un mercato rialzista nel quarto trimestre, a condizione che le pressioni macroeconomiche si siano attenuate.</p>
<p><strong>Harris ha annunciato una lista di posizioni politiche proposte, senza menzionare la criptovaluta</strong></p>
<p>Il sito web della campagna del vicepresidente degli Stati Uniti e candidato presidenziale democratico Harris ha pubblicato un elenco delle posizioni politiche proposte per la sua futura amministrazione presidenziale, tra cui tagli fiscali per le famiglie della classe media e rendere gli affitti più favorevoli, ma non vi è alcuna menzione di argomenti legati alle criptovalute.</p>
<p>Nel suo programma correlato “Sostenere l’innovazione americana”, Harris garantirà lo sviluppo florido dell’industria e dei lavoratori americani basato sui progressi compiuti da questa amministrazione. Il vicepresidente Harris continuerà a sostenere il leadership degli Stati Uniti nei settori dei semiconduttori, dell’energia pulita, dell’intelligenza artificiale e di altri settori all’avanguardia del futuro.</p>
<p><strong>Stratega Citigroup: il portafoglio dei clienti riflette il sentiment bearish nel mercato azionario statunitense
</strong></p>
<p>Gli strateghi di Citigroup ritengono che il sell-off nel mercato azionario statunitense della scorsa settimana potrebbe portare a ulteriori cali nei principali indici azionari. Lo stratega Chris Montagu e altri hanno affermato in un rapporto ai clienti lunedì che un gran numero di posizioni lunghe nell’indice S&amp;P 500 sono state liquidate, insieme a un aumento delle posizioni corte nell’indice Nasdaq 100, indicando un cambiamento nell’appetito per il rischio verso una tendenza ribassista più diretta.</p>
<p>Hanno dichiarato che le operazioni di de-risk dei fondi hedge sull’indice S&amp;P 500 hanno comportato una esposizione totale pari solo alla metà del picco di metà luglio. Montagu ha scritto che la liquidazione forzata delle posizioni long potrebbe intensificare o accelerare la vendita nel breve termine e, se questa tendenza continua, le nuove posizioni short aggiunte venerdì sono probabilmente destinate a portare gli indicatori focalizzati sulla tecnologia in posizioni nette short.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20ha20guidato20il20mercato20verso20un20significativo20rimbalzo20FTM20ha20fatto20bene607216"><a name="Tendenze di mercato: BTC ha guidato il mercato verso un significativo rimbalzo, FTM ha fatto bene" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC ha guidato il mercato verso un significativo rimbalzo, FTM ha fatto bene</h2><h3 id="h3-Monete20principali572214"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è rimbalzato significativamente, raggiungendo un picco di $58.000, ed è ora sceso a circa $57.000, ancora in un mercato volatile;</p>
<p>ETH ha ripiegato con BTC, ma l’aumento complessivo è stato relativamente piccolo, indicando una performance dei prezzi relativamente debole. Il volume di scambio e l’afflusso di ETH ETF sono ancora relativamente piccoli;</p>
<p>Le altcoin sono generalmente aumentate e il settore dei Meme rimane il migliore in termini di performance;</p>
<p>In termini di indicatori di dati, l’indice AHR999 oggi è stato 0,59, con un leggero rimbalzo del prezzo che accompagna l’indice; l’indice Fear &amp; Greed è 33, indicando un leggero alleviamento del panico, ma il volume degli scambi di mercato rimane lento.</p>
<h3 id="h3-Punti20caldi20del20mercato836023"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p>Catena pubblica <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>: FTM è diventato il miglior token di catena pubblica nelle ultime 24 ore, con un aumento superiore al 15%. FTM ha ottenuto tre guadagni giornalieri consecutivi. Dal punto di vista delle notizie, è stato lanciato il testnet Sonic di Fantom, e attualmente c’è un alto livello di partecipazione della comunità nell’interazione con il testnet. Tuttavia, secondo il canale ufficiale Discord, non ci saranno distribuzioni gratuite di token per l’interazione con il testnet. Ad agosto di quest’anno, <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> ha annunciato ufficialmente il cambio di nome in Sonic Labs e adotterà il nuovo token S, con FTM che scambia i token S 1:1.</p>
<p>Settore dei Meme: PEOPLE, un concetto delle elezioni presidenziali degli Stati Uniti, è salito di oltre il 20% in 24 ore, diventando la Meme coin di punta con il miglior aumento. Domani, ora di Pechino, i candidati presidenziali americani Trump e Harris avranno un dibattito televisivo, con il mercato che scommette in anticipo che i due candidati potrebbero menzionare politiche legate alle criptovalute durante il dibattito. Le Meme coin POPCAT e MIGGLES nel settore dei gatti sono salite di oltre il 15% in 24 ore. Attualmente, non esiste una Meme coin legata ai gatti con un valore di mercato superiore a 1 miliardo di dollari e le ottime performance di prezzo di POPCAT potrebbero aiutarla a prendere il comando.</p>
<h2 id="h2-Macroeconomia20I20tre20principali20indici20del20mercato20azionario20degli20Stati20Uniti20sono20generalmente20aumentati20e20gli20asset20potrebbero20essere20stati20pienamente20inclusi20nellaspettativa20di20tagli20dei20tassi20di20interesse929988"><a name="Macroeconomia: I tre principali indici del mercato azionario degli Stati Uniti sono generalmente aumentati e gli asset potrebbero essere stati pienamente inclusi nell’aspettativa di tagli dei tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: I tre principali indici del mercato azionario degli Stati Uniti sono generalmente aumentati e gli asset potrebbero essere stati pienamente inclusi nell’aspettativa di tagli dei tassi di interesse</h2><p>I tre principali indici azionari statunitensi sono tutti saliti oltre l’1%, con l’indice S&amp;P 500 che è salito dell’1,16% a 5471,05 punti; il Dow Jones Industrial Average è salito del 1,20% a 40.829,59 punti; l’indice Nasdaq è salito dell’1,16% a 16.884,60 punti.</p>
<p>Il rendimento del Treasury decennale di riferimento è del 3,70%, mentre il rendimento del Treasury a 2 anni, che è il più sensibile al tasso di politica della Federal Reserve, è del 3,68%.</p>
<p>Tra le popolari azioni statunitensi, Apple è salita dello 0,04%, Microsoft è salita dell’1,00%, Nvidia è salita del 3,54%, Amazon è salita del 2,34%, Google C è scesa dell’1,70%, Google A è scesa dell’1,46%, Meta è salita dello 0,90%, TSMC è salita del 3,85%, Tesla è salita del 2,63% e AMD è salita del 2,83%.</p>
<p>La settimana scorsa, sotto l’influenza dell’ultimo dato chiave sull’occupazione prima del taglio dei tassi di interesse, il mercato azionario statunitense ha subito un significativo ritracciamento, con il tasso di disoccupazione in calo e il ripristino dei nuovi posti di lavoro al di sotto delle aspettative. Ciò significa che l’occupazione si è effettivamente rallentata, ma non è sufficiente per confermare una recessione. Per quanto riguarda i tagli dei tassi di interesse, un taglio di 25BPS a settembre rimane lo scenario di riferimento. Dopo la pubblicazione dei dati sull’occupazione non agricola, il mercato ha intrapreso un feroce gioco di tagli dei tassi di interesse a settembre, con la probabilità di un taglio del tasso del 50BPS che è salita al 50% in un primo momento, ma alla fine è scesa al 30%. Quando un taglio dei tassi potrebbe essere imminente, è importante notare che gli asset potrebbero già essere stati completamente contabilizzati nell’aspettativa di un taglio dei tassi e la magnitudine complessiva del taglio dei tassi potrebbe anche essere limitata.</p>
<h3 id="h3-Conclusion954527"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>Globalmente, il mercato delle criptovalute è stato attivo di recente, ma c’è ancora un certo livello di rischio di volatilità. Le tendenze di Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> continueranno ad influenzare il sentimento complessivo e la direzione del mercato. La forte performance delle altcoin, in particolare del settore Meme, ha iniettato vitalità nel mercato, ma gli investitori devono rimanere cauti e evitare di inseguire ciecamente prezzi più alti. Gli indicatori dati mostrano che il sentimento di mercato è rimbalzato, ma l’indice della paura e dell’avidità è ancora a un livello basso, e dobbiamo continuare a prestare attenzione alle dinamiche di mercato e all’impatto di importanti eventi macroeconomici.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing</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. Sarà consentito ripostare l'articolo a condizione che Gate.io venga menzionato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>