Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGNvbnNvbGlkYXRvIGEgbGl2ZWxsaSBlbGV2YXRpIG1hIHRhc3NvIGRpIGRvbWluYXppb25lIGRpbWludWl0bywgYWx0Y29pbiBpbiByaWFsem8gaW4gdHV0dG8gaWwgbWVyY2F0bw==

2024-09-25, 04:45

<p><img src="https://gimg2.gateimg.com/image/article/17272393229.25.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20cripto20gli20ingressi20ETF20BTC20hanno20superato20i2010020milioni20di20dollari20gli20ETF20ETH20raramente20hanno20registrato20ingressi20superiori20a206020milioni20di20dollari605036"><a name="Riassunto giornaliero cripto: gli ingressi ETF BTC hanno superato i 100 milioni di dollari, gli ETF ETH raramente hanno registrato ingressi superiori a 60 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero cripto: gli ingressi ETF BTC hanno superato i 100 milioni di dollari, gli ETF ETH raramente hanno registrato ingressi superiori a 60 milioni di dollari</h2><p>Secondo Farside Investor, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno registrato flussi netti in entrata di $135.26 milioni ieri. Blackrock IBIT ha avuto flussi in entrata di $98.2 milioni e Fidelity FBTC ha avuto flussi netti in entrata di $16.8 milioni.</p>
<p>Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato un afflusso netto di $62,43 milioni, mentre BlackRock ETHA ha registrato un afflusso di $59,17 milioni.</p>
<p><strong>TRU è brevemente sceso di oltre il 5% a causa delle accuse della SEC</strong></p>
<p>La notizia che la Securities and Exchange Commission degli Stati Uniti ha accusato gli operatori di stablecoin TUSD TrustToken e TrueCoin di ingannare gli investitori riguardo ai piani di investimento in stablecoin ha avuto un impatto su TRU, che è sceso più del 5% per un breve periodo, scambiandosi temporaneamente a $0.0975. Secondo la SEC, il 99% delle riserve di TUSD è investito in “fondi offshore speculativi”.</p>
<p><strong>Le azioni di MicroStrategy sono aumentate del 119 percento finora quest’anno, rispetto al 35 percento di BlackRock IBIT</strong></p>
<p>Il lancio degli ETF di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> negli Stati Uniti l’11 gennaio di quest’anno è diventato uno degli eventi finanziari più importanti. Secondo Farside, questi ETF, tra cui il BlackRock iShares Bitcoin Trust (IBIT), hanno attratto $17.7 miliardi di afflussi netti dall’inizio.</p>
<p>Per alcuni, IBIT è diventato un concorrente di MicroStrategy (MSTR), nota per le sue grandi disponibilità di Bitcoin e il suo modello di business duale. MicroStrategy, guidata dall’utive Chairman Michael Thaler, detiene attualmente 252.220 Bitcoin del valore di circa 16 miliardi di dollari. Attualmente, il titolo MicroStrategy è aumentato del 119%, mentre IBIT è aumentato del 35%, mostrando una differenza di performance di oltre tre volte.</p>
<p>Come ETF, il Bitcoin Trust di BlackRock ha un rapporto di spese dello 0,25 percento, mentre MicroStrategy non addebita tali commissioni agli azionisti. MicroStrategy trae beneficio dal reddito generato dalla sua attività di analisi, garantendo stabilità finanziaria e dai suoi investimenti in bitcoin. MSTR ha la capacità di raccogliere fondi attraverso offerte di debito e di capitale, mentre IBIT si affida ai flussi diretti degli investitori.</p>
<p><strong>Jupiter ha rilasciato una bozza di proposta per smaltire oltre 215 milioni di token JUP non assegnati</strong></p>
<p>Jupiter ha collaborato con Meow per pubblicare una bozza di proposta per smaltire 215 milioni di token JUP non assegnati. I token derivano da porzioni non reclamate o non ridistribuite della distribuzione gratuita di Jupiter all’inizio di quest’anno, e la proposta presenta tre opzioni:</p>
<p>1）Utilizzare i token per il programma di ricompensa per lo staking attivo (ASR) per l’anno a venire;<br>2）Bruciare questi token;<br>3）Restituire il token ai portafogli Multi-signature della comunità.</p>
<p>Sulla base della bozza, il team di Jupiter raccomanda “fortemente” la prima opzione, sostenendo che il programma ASR ha promosso efficacemente il coinvolgimento della comunità e il voto DAO. Negli ultimi due trimestri, sono stati messi in staking 361 milioni di JUP, con oltre 585.000 indirizzi partecipanti e una media di 280 milioni di JUP per voto. Se l’opzione 1 sarà adottata, 50 milioni di JUP saranno distribuiti agli elettori ogni trimestre per quattro trimestri.</p>
<h2 id="h2-Tendenze20di20mercato20POPCAT20ha20raggiunto20un20record20storico20SUI20si2020comportato20in20modo20forte651937"><a name="Tendenze di mercato: POPCAT ha raggiunto un record storico, SUI si è comportato in modo forte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: POPCAT ha raggiunto un record storico, SUI si è comportato in modo forte</h2><h3 id="h3-Mainstream20Coins702378"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>Nuovi progetti di blockchain pubblica come SUI e SEI sono aumentati vertiginosamente. Dopo che SUI ha raggiunto un grande sblocco all’inizio di settembre, un gran numero di OTC a istituzioni di investimento, le recenti prestazioni di prezzo sono forti, vicine al massimo storico, e la capitalizzazione di mercato attuale è entrata nella top 20. Inoltre, Sui ha aperto la pre-vendita di console per videogiochi, la posizione fiduciaria Grayscale SUI, e altre notizie hanno stimolato le prestazioni di prezzo di SUI;</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> I progetti di blockchain pubblica sono saliti collettivamente, SOL, WIF, POPCAT, FIDA e altre prestazioni eccezionali. POPCAT, un meme sulla catena di Solana, ha superato $1,05, raggiungendo un nuovo massimo storico. Dopo due mesi di consolidamento al minimo, la moneta meme dog WIF ha superato di nuovo i $2 oggi, aumentando di quasi il 100% rispetto al prezzo di agosto;</p>
<p>Altre monete, inclusi ENA, ALT e SAGA, sono salite bruscamente. Le altcoin menzionate in precedenza hanno ripreso dopo aver subito un calo del 90%, e il futuro del mercato resta da vedere.</p>
<h3 id="h3-Punti20Caldi20del20Mercato411405"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>BTC è stato scambiato lateralmente a un livello elevato, gli ETF BTC hanno ripreso gli afflussi di capitale positivi e il miglioramento dell’ambiente macro ha aumentato la fiducia nel prezzo di BTC fino a un certo punto;</p>
<p>ETH ha oscillato tra $2.600 e $2.700, in attesa che il mercato si rompa prima che ETH possa inaugurare il proprio mercato indipendente;</p>
<p>Le altcoin sono generalmente aumentate. Molti di esse hanno raddoppiato il prezzo dal minimo, e POPCAT, SUI e altre criptovalute hanno superato o sono vicine al massimo storico.</p>
<h2 id="h2-Macroeconomia20le20azioni20statunitensi20hanno20chiuso20in20rialzo20con20il20mercato20diviso20sulle20prospettive20economiche867894"><a name="Macroeconomia: le azioni statunitensi hanno chiuso in rialzo, con il mercato diviso sulle prospettive economiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: le azioni statunitensi hanno chiuso in rialzo, con il mercato diviso sulle prospettive economiche</h2><p>Gli indici azionari statunitensi hanno chiuso in rialzo, con lo S&amp;P 500 in rialzo dello 0,25 percento a 5.732,93. Il Dow Jones industrial average è salito dello 0,20% a 42.208,22; il Nasdaq è salito dello 0,56% a 18.074,52. Il benchmark del tasso decennale ha reso il 3,74 percento, mentre il tasso biennale, il più sensibile al tasso di politica della Fed, ha reso il 3,49 percento.</p>
<p>I dati sul posizionamento delle azioni statunitensi hanno mostrato che dalla decisione della Fed della scorsa settimana, i mercati dei tassi di interesse hanno iniziato a prepararsi per il 7 novembre. Gli interessi aperti nei future dei Treasury a due anni sono aumentati notevolmente, con il numero di contratti in scadenza a dicembre 2024 salito a circa 4,4 milioni di contratti. Anche le scommesse sui future di dicembre legate al tasso di finanziamento garantito overnight (SOFR) sono aumentate in modo significativo. Tuttavia, con diversi responsabili politici che inviano segnali contrastanti per la riunione di novembre, i trader non hanno fatto grandi scommesse in una direzione.</p>
<p>I funzionari della Fed sono in qualche modo divisi sulle prospettive dell’economia e sul percorso della politica. Alcuni funzionari hanno detto che la situazione economica attuale richiedeva un aggiustamento della politica monetaria più aggressivo per affrontare potenziali rischi al ribasso. Altri temono che una politica eccessivamente accomodante potrebbe scatenare un rimbalzo dell’inflazione. Il governatore della Fed Jeffrey Bowman ha espresso il voto contrario solitario quando la Fed ha tagliato il suo tasso di riferimento di 50 punti base il 18 settembre, preferendo un taglio più piccolo di 25 punti base. Si concentra principalmente sul componente di lotta all’inflazione del doppio mandato della Fed, a differenza di molti funzionari della Fed che si concentrano sugli sviluppi del mercato del lavoro degli Stati Uniti.</p>
<h3 id="h3-Conclusione9779"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>L’umore generale del mercato rimane cauto. BTC è probabile che continui a muoversi all’interno di un range di consolidamento nel breve termine, mentre ETH avrà bisogno di ulteriori stimoli di mercato per uscire dai suoi massimi attuali. Il comportamento di TIA di pull anticipato prima dello sblocco potrebbe causare volatilità dei prezzi dopo lo sblocco, e gli investitori devono essere vigili. La rapida salita e il ritracciamento di NEIROCTO mostrano l’entusiasmo speculativo a breve termine del mercato per il token meme, ma il rischio di un ritracciamento deve essere preso in considerazione.</p>
<p>I settori dell’AI e dei meme rimarranno punti caldi nel mercato, e si prevede che questi settori continueranno ad attrarre flussi di capitale nel breve termine.</p>
<p>In the <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> In un mercato in cui squadre e grandi giocatori possono influenzare i prezzi attraverso la manipolazione del mercato, gli investitori devono essere cauti riguardo agli eventi pubblici di sblocco di token su larga scala. La politica di riduzione dei tassi d’interesse della Federal Reserve e i cambiamenti nell’ambiente economico globale continueranno ad influenzare il mercato criptato, e gli investitori devono concentrarsi sugli indicatori macroeconomici.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa</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 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>