Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHN0YWduYSwgUE9QQ0FUIGUgTkVJUk9DVE8gYXVtZW50YW5vIHNpZ25pZmljYXRpdmFtZW50ZQ==

<p><img src="https://gimg2.gateimg.com/image/article/17270665949.23.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BTC20ETF20Continua20a20Ricevere20Flussi20Positivi20OP20Pronto20per20un20Grande20Sblocco874613"><a name="Crypto Daily Digest: BTC ETF Continua a Ricevere Flussi Positivi, OP Pronto per un Grande Sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BTC ETF Continua a Ricevere Flussi Positivi, OP Pronto per un Grande Sblocco</h2><p>Secondo i dati di Farside Investor, venerdì il mercato statunitense <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">bitcoin](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-btc”" target="“_blank”" class="“blog" _interno_="" [collegamento<="" a=""> L’ETF di Bitcoin ha registrato ingressi netti di 92 milioni di dollari ieri, con Fidelity FBTC che ha registrato ingressi netti di 26,1 milioni di dollari e ARKB che ha registrato ingressi netti di 22 milioni di dollari. BlackRock IBIT non ha avuto ingressi o uscite.</a></p><a  rel="nofollow noopener noreferrer"  href=")-btc”" target="“_blank”" class="“blog" _interno_="" [collegamento<="" a="">
<p>Venerdì, gli ETF Spot degli Stati Uniti su Ether hanno registrato un afflusso netto di $2,9 milioni ieri, con $2,9 milioni che sono entrati in Grayscale ETH e nessun afflusso o deflusso in altri ETF su ETH.</p>
<p>Dati: le commissioni di rete Ether e la distruzione di ETH aumentano nell’ultimo trimestre e le attività di rete attive scendono ai minimi dell’anno. Le commissioni di transazione di Ether (media mobile a 7 giorni) sono aumentate nelle ultime 3 settimane, secondo i dati di The Block. La sua ultima commissione (settembre 2021) è stata di $3,52, più del triplo della commissione del 1° settembre di $0,85, mostrano i dati.</p>
<p>L’aumento delle commissioni di transazione ha anche aumentato il tasso di distruzione di Ether, che è aumentato in modo simile da 80,27 ETH il 1 settembre a 1.360 ETH il 21 settembre, un aumento del 1.600% in soli tre settimane.</p>
<p>Tuttavia, nonostante l’aumento delle commissioni di transazione e la distruzione, gli account attivi della rete (media mobile di 7 giorni) sono diminuiti al loro valore più basso dell’anno fino ad ora, in calo dell’11% rispetto all’inizio di questo mese. Il numero attuale di account attivi, che si aggira intorno a 385.000, è il più basso dal 1° dicembre 2023 per la rete.</p>
</a><h3 id="h3-Harris20fa20la20prima20dichiarazione20incoragger20lo20sviluppo20dellindustria20delle20criptovalute20se20eletta20presidente731252"><a  rel="nofollow noopener noreferrer"  href=")-btc”" target="“_blank”" class="“blog" _interno_="" [collegamento<="" a=""></a><a name="Harris fa la prima dichiarazione: incoraggerà lo sviluppo dell’industria delle criptovalute se eletta presidente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Harris fa la prima dichiarazione: incoraggerà lo sviluppo dell’industria delle criptovalute se eletta presidente</h3><p>Secondo Bloomberg, la prossima candidata alla presidenza degli Stati Uniti e attuale vicepresidente Kamala Harris ha dichiarato durante una raccolta fondi presso il Cipriani Wall Street a Manhattan:</p>
<p>“Riunirò la forza lavoro, i fondatori di piccole imprese e gli innovatori, e le grandi aziende. Lavoreremo insieme per investire nella competitività dell’America e nel futuro dell’America. Incoraggeremo tecnologie innovative come l’intelligenza artificiale e gli asset digitali, proteggendo nel contempo i nostri consumatori e gli investitori.”<br>Si dice che questa sia la prima volta che Harris ha commentato personalmente sulle criptovalute come candidato presidenziale democratico.</p>
<h3 id="h3-I20dati20sullunlocking20di20questa20settimana20in20sintesi2010120milioni20di20valore20totale20sbloccato20OP20VENOM20e20altro20pronto20per20un20grande20sblocco60430"><a name="I dati sull’unlocking di questa settimana in sintesi: $101 milioni di valore totale sbloccato, OP, VENOM e altro pronto per un grande sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I dati sull’unlocking di questa settimana in sintesi: $101 milioni di valore totale sbloccato, OP, VENOM e altro pronto per un grande sblocco</h3><p>Secondo i dati sugli sblocchi di token, il valore totale di tutti i token sbloccati nel mercato principale nella prossima settimana ammonta a $101 milioni, con:</p>
<ul>
<li>Venom sbloccerà 235 milioni di VENOM alle 16:00 del 25 settembre, del valore di circa $25,55 milioni, pari al 12,66% dell’offerta circolante;</li></ul>
<p>-Ygg sbloccherà 14,08 milioni di YGG alle ore 22:00 del 27 settembre, che rappresentano circa $6,5 milioni, o il 3,65% dell’offerta circolante;</p>
<p>SingularityNET sblocca 8,19 milioni di AGIX alle 0800 del 28 settembre, del valore approssimativo di $5,82 milioni, pari al 1,63% dell’offerta circolante;</p>
<p>Ethena sbloccherà 14,89 milioni di ENA alle 15:00 del 29 settembre, del valore di circa 4,3 milioni di dollari, pari allo 0,78% dell’offerta circolante;</p>
<ul>
<li><a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a>-op” target=”_blank” class=”blog_inner_link”&gt;L’ottimismo sbloccherà 31,34 milioni di OP alle 08:00 del 30 settembre, per un valore di circa 55,47 milioni di dollari, pari al 2,64% dell’offerta in circolazione;</li></ul>
<p>Tendenze di mercato: BTC ETF riprende grandi afflussi, settore dei meme guida il mercato al rialzo</p>
<p>PUNTI CALDI DI MERCATO<br>-La piattaforma di catene pubbliche SUI è salita alle stelle, il progetto ecologico BLUB ha ottenuto risultati sorprendenti; ETH e SOL si sono mantenuti stabili in questa fase di mercato, il mercato ha iniziato a speculare su altri progetti di catene pubbliche e il TVL complessivo di Sui ha raggiunto un record di $1,1 miliardi; <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">Solana</a> La conferenza di chiusura di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Break Point è terminata, le prestazioni complessive di SOL sono state mediocri e il progetto eco-meme POPCAT di Solana è stato vicino al suo massimo storico; il meme board ha guidato il mercato al rialzo; ETF BTC ha ripreso un grande afflusso, il meme board ha guidato il mercato al rialzo. POPCAT, un progetto meme dell’ecosistema di Solana, è vicino al suo massimo storico;</p>
<ul>
<li><p>NEIROCTO, MOODENG e TERMINUS nel meme board sono aumentati, e TERMINUS, il meme del concetto di Mars City menzionato da Musk, è aumentato quasi 100 volte la settimana scorsa, quindi dobbiamo essere vigili per il rischio di ritracciamento a breve termine, e in generale, l’entità del ritracciamento delle popolari monete meme sarà maggiore;</p>
</li><li><p>TAO e AI nel segmento AI sono aumentati, mentre WLD, il token leader nel segmento AI, ha avuto una performance scarsa e la pressione giornaliera di sblocco su WLD ha soppresso le prestazioni dei prezzi;</p>
</li></ul>
<h3 id="h3-Tendenza20Generale20di20Mercato204541"><a name="Tendenza Generale di Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza Generale di Mercato</h3><ul>
<li>BTC ha oscillato in un range stretto tra $62,000 e $64,000 durante il fine settimana, con continui flussi positivi nell’ETF di BTC;</li><li>ETH di nuovo sopra i $2,600, guadagni complessivi ancora in ritardo rispetto al mercato più ampio, speculazione di mercato su ETH come killer della catena pubblica;</li></ul>
<p>Le monete Cottage in generale hanno subito un ritracciamento e una caduta durante la consolidazione laterale del mercato generale, mentre POPCAT, SUI e altre hanno registrato una forte performance;</p>
<h3 id="h3-Indicatori20dei20dati64430"><a name="Indicatori dei dati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indicatori dei dati</h3><p>-Oggi, l’indice AHR999 è 0,72, attuale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo BTC</a> è ancora adatto per gli investimenti a lungo termine; l’indice di paura e avidità è 50, il sentiment di mercato è neutrale e il mercato potrebbe continuare a mantenersi nel breve termine.</p>
<h2 id="h2-Macro20Azioni20statunitensi20si20muovono20ripetutamente20il20dollaro20statunitense20crolla623589"><a name="Macro: Azioni statunitensi si muovono ripetutamente, il dollaro statunitense crolla" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Azioni statunitensi si muovono ripetutamente, il dollaro statunitense crolla</h2><p>La tendenza dei tre principali indici delle azioni statunitensi si ripete, in cui l’indice S&amp;P 500 è sceso dello 0,19% a 5702,55 punti; l’indice Dow Jones è salito dello 0,09% a 42.063,36 punti; l’indice Nasdaq è sceso dello 0,36% a 17.948,32 punti. La scorsa settimana, il Dow è salito dell’1,62% per la settimana, il Nasdaq è salito dell’1,49% per la settimana e l’indice S&amp;P 500 è salito dell’1,36% per la settimana.</p>
<p>Il titolo di Stato decennale statunitense di riferimento ha reso il 3,73%, mentre il titolo di Stato statunitense a due anni, che è più sensibile al tasso di interesse della Fed, ha reso il 3,55%.</p>
<p>Wall Street ha ottenuto un grande taglio dei tassi come previsto, ma il mercato non è riuscito a sostenere il rally. La Fed ha tagliato il suo tasso chiave di prestito notturno di mezzo punto percentuale (50 punti base) mercoledì scorso. Questo è stato un cambiamento rispetto al primo taglio dei tassi nel ciclo di allentamento precedente della Fed e rispetto all’aspettativa generale prima che il mercato iniziasse a digerire un taglio dei tassi più ampio la scorsa settimana. Tuttavia, le azioni sono salite brevemente dopo l’annuncio della risoluzione dei tassi, ma poi hanno faticato a guadagnare ulteriormente poiché gli investitori temevano che un taglio dei tassi più deciso segnalasse un aumento della debolezza economica in futuro, anche se l’inflazione è già vicina al target del 2% della Fed.</p>
<h3 id="h3-Riassunto655411"><a name="Riassunto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto</h3><p>Si prevede che i prezzi di BTC continueranno a stabilizzarsi o addirittura aumentare nel breve termine a causa dei flussi continui nell’ETF di BTC. eTH, sebbene sopra i $2.600, è rimasto indietro rispetto al mercato più ampio in termini di guadagni e sarà necessario monitorarlo per vedere se riuscirà a colmare il divario con BTC nelle prossime settimane. L’aumento delle commissioni e la distruzione sul <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">ethereum</a> La rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> potrebbe sostenere i prezzi dell’ETH, ma il calo del numero di account attivi deve essere motivo di allarme.</p>
<p>Un gran numero di token saranno sbloccati nella prossima settimana, in particolare <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> e Venom. Questi sblocchi potrebbero creare una vendita a breve termine sul mercato e la volatilità dei prezzi successiva agli sblocchi deve essere monitorata attentamente. Il settore delle catene pubbliche e il settore dei memi potrebbero continuare ad attirare afflussi, in particolare i performer più forti SUI e POPCAT.</p>
<p>Inoltre, i movimenti delle azioni americane e il tasso di cambio del dollaro americano continueranno ad avere un certo impatto su di esso. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a>. La direzione della politica della Fed e la situazione economica globale richiederanno un’attenzione continua.</p>
<p>In generale, il mercato è attualmente in uno stato relativamente stabile, ma lo sblocco di grandi token e l’incertezza macroeconomica della settimana prossima potrebbero portare un po’ di volatilità. Gli investitori dovrebbero prestare molta attenzione ai flussi di fondi del BTC ETF, alle dinamiche della rete ETH e allo sblocco dei token principali. Allo stesso tempo, prestare attenzione alle prestazioni dei settori di mercato caldi e all’impatto dei fattori macroeconomici al fine di regolare tempestivamente le strategie di investimento.</p>
<div class="blog-details-info"><br><div>Autore:<strong> icing</strong><br><div>Traduttore :<strong>icing</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali in caso di violazione del copyright.<br></div><p></p><br></div></div></div></div>