Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIG9zY2lsbGEgZSBjYWRlLCBsYSBwcm9kdXppb25lIGRpIFNUWCBzYXLDoCBkaW1lenphdGE=

2024-09-02, 04:27

<p><img src="https://gimg2.gateimg.com/image/article/17252510949.2.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20cripto20gli20introiti20dei20minatori20di20Bitcoin20ad20agosto20raggiungono20un20nuovo20minimo20dellanno20STX20vedr20un20dimezzamento83401"><a name="Riassunto giornaliero delle cripto: gli introiti dei minatori di Bitcoin ad agosto raggiungono un nuovo minimo dell’anno, STX vedrà un dimezzamento." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle cripto: gli introiti dei minatori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ad agosto raggiungono un nuovo minimo dell’anno, STX vedrà un dimezzamento.</h2><p>Secondo i dati di Farside Investor, il mercato statunitense <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">bitcoin](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-btc&quot;" target="_blank" class="blog _interno_ [collegamento</a> L’ETF Bitcoin ha avuto un deflusso netto di 175 milioni di dollari lo scorso venerdì, segnando quattro giorni consecutivi di deflussi netti la scorsa settimana. Tra questi, BlackRock IBIT non ha afflussi o deflussi di fondi, e il principale deflusso di fondi proviene da ARKB e GBTC.</p>
<p>Venerdì scorso non c’è stato alcun flusso o deflusso di fondi nel mercato statunitense <a  rel="nofollow noopener noreferrer"  href=" price="" &lt;a="" nofollow="" noopener="" noreferrer"="">ethereum</a>-eth” target=“_blank” class=“blog_inner_link”&gt;Gli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e il volume complessivo di trading degli ETF ETH erano lenti.</p>
<p><strong><a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">stacks</a> Si prevede che <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> sarà aggiornato con successo il 15 settembre e la produzione di STX sarà dimezzata.</strong></p>
<p>Secondo fonti ufficiali, dopo il riuscito aggiornamento di Stacks Nakamoto questo mese, la ricompensa verrà dimezzata secondo le nuove regole di consenso, con solo 500 token STX assegnati per blocco di Bitcoin. Secondo il piano, il team prevede di effettuare un hard fork all’altezza del blocco 861.500 in Stacks, attivando tutte le nuove regole di Stacks Nakamoto e contemporaneamente raggiungendo una riduzione della produzione migliorando l’efficienza della rete Stacks. Sulla base dell’altezza corrente del blocco, si prevede che l’aggiornamento sarà completato con successo intorno al 15 settembre.</p>
<p>Si riporta che l’attuale blockchain di Stacks adotti il meccanismo di mining POX, in cui i minatori impegnano Bitcoin e ricevono in premio token STX. Ogni blocco di Bitcoin premia 1.000 token STX.</p>
<p><strong>I guadagni dei minatori di Bitcoin di agosto hanno raggiunto un nuovo minimo per l’anno</strong></p>
<p>Secondo i dati di TheBlock, i profitti dei minatori di Bitcoin hanno toccato un nuovo minimo per l’anno ad agosto, generando un totale di $851,36 milioni in sussidi e commissioni, di cui $20,76 milioni provengono dalle commissioni on-chain.</p>
<p>I ricavi minerari ad agosto sono diminuiti di 99,75 milioni di dollari rispetto a luglio e le commissioni di trading on-chain contribuite dagli utenti sono diminuite di 4,14 milioni di dollari rispetto al mese precedente. Tra i blocchi con altezze comprese tra 855.014 e 859.303, i minatori di Bitcoin hanno estratto un totale di 4.289 blocchi, Foundry USA ha estratto 1.248 blocchi, pari al 29,10%, e Antpool ha estratto 1.074 blocchi, pari al 25,04%.</p>
<p><strong>Co-fondatore di Sui: Il volume mensile di sblocco di SUI rappresenta circa il 2,6% dell’offerta circolante ed è ancora in diminuzione</strong></p>
<p>Il co-fondatore e CEO di Sui, evan.sui, ha risposto alle discussioni sui social media riguardo a “Tasso di inflazione annuale di SUI superiore al 250%” dicendo: “Accogliamo le critiche. Questo è l’unico modo per migliorarci. Il volume mensile di sblocco di SUI rappresenta circa il 2,6% dell’offerta circolante e sta ancora diminuendo.</p>
<p>Inoltre, Even ha anche affermato che SUI è una delle poche catene POS fisse di fornitura, anziché avere un tasso di inflazione del 5% -8% come la maggior parte delle altre catene.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato20complessivo2020in20fluttuazione20e20in20calo20e20IMX20si20trover20di20fronte20a20grandi20opportunit20di20sblocco72129"><a name="Tendenze di mercato: il mercato complessivo è in fluttuazione e in calo, e IMX si troverà di fronte a grandi opportunità di sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato complessivo è in fluttuazione e in calo, e IMX si troverà di fronte a grandi opportunità di sblocco</h2><h3 id="h3-Monete20principali992047"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è oscillato e caduto, attualmente si aggira intorno ai $57.000. L’ETF BTC ha registrato nuovamente una significativa fuoriuscita di $175 milioni nell’ultimo giorno di negoziazione;</p>
<p>ETH ha registrato anche una debolezza, scendendo sotto i $2.400 questa mattina. Gli ETF ETH non hanno avuto afflussi o deflussi di fondi nella giornata di negoziazione precedente e il volume di negoziazione degli ETF ETH è stato molto al di sotto delle aspettative;</p>
<p>Le altcoin sono ampiamente disponibili e il mercato è silenzioso senza evidenti punti caldi;</p>
<p>In termini di indicatori di dati, l’indice AHR999 di oggi è 0,6, che si avvicina sempre di più all’indicatore di pesca in fondo; L’indice Fear &amp; Greed è 26, indicando uno stato di paura sostenuta nel sentiment di mercato.</p>
<h3 id="h3-Punti20caldi20del20mercato671868"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p>Questa settimana, IMX e TAIKO avranno un grande sblocco: Taiko sbloccherà 12 milioni di TAIKO alle 20:00 del 5 settembre, del valore approssimativo di $19.32 milioni, corrispondente al 19.02% dell’offerta circolante; Immutable sbloccherà 32.47 milioni di token IMX del valore approssimativo di $44.17 milioni alle 8:00 (ora di Pechino) del 6 settembre, corrispondente al 2.06% dell’offerta circolante;</p>
<p>Migrazione del token FRONT: il token FRONT di Frontier verrà migrato al token Self Chain SLF in un rapporto 1:1, ma il numero totale di token SLF sarà significativamente aumentato. Il numero totale di token FRONT è solo 90 milioni, mentre il numero totale di token SLF è 360 milioni. In realtà, si tratta di una diluizione per i detentori del token FRONT, che sta anche affrontando enormi interrogativi nella comunità.</p>
<h2 id="h2-Macroeconomia20le20azioni20statunitensi20hanno20chiuso20in20rialzo20venerd20scorso20e20questa20settimana20la20Fed20pubblicher20i20dati20sugli20occupati20agricoli20non20stagionali20di20agosto489340"><a name="Macroeconomia: le azioni statunitensi hanno chiuso in rialzo venerdì scorso, e questa settimana la Fed pubblicherà i dati sugli occupati agricoli non stagionali di agosto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: le azioni statunitensi hanno chiuso in rialzo venerdì scorso, e questa settimana la Fed pubblicherà i dati sugli occupati agricoli non stagionali di agosto</h2><p>I tre principali indici del mercato azionario statunitense hanno chiuso in rialzo, con l’indice S&amp;P 500 che è salito dell’1,01% a 5648,40 punti; il Dow Jones Industrial Average è aumentato dello 0,55% a 41563,08 punti; l’indice Nasdaq è salito dell’1,13% a 17713,62 punti. La scorsa settimana, l’indice Dow Jones è salito dello 0,94% in una settimana, l’indice Nasdaq è sceso dello 0,92% in una settimana e l’indice S&amp;P 500 è salito dello 0,24% in una settimana.</p>
<p>Inoltre, il rendimento del benchmark del Tesoro decennale è del 3,91%, e il rendimento del Tesoro a 2 anni, che è il più sensibile al tasso di politica della Fed, è del 3,91%.</p>
<p>Tra le azioni popolari statunitensi, Apple è scesa dello 0,34%, Microsoft è salita dello 0,97%, Nvidia è salita dell’1,51%, Google C è salita dell’1,05%, Google A è salita dello 0,99%, Amazon è salita del 3,71%, Meta è salita dello 0,60%, TSMC è salita dell’1,51%, Tesla è salita del 3,80% e AMD è salita del 2,11%.</p>
<p>Guardando avanti alla prossima settimana, gli Stati Uniti rilasceranno dati importanti come la folta serie di impieghi agricoli stagionalmente adeguati, il tasso di disoccupazione e il salario orario medio per agosto. La Federal Reserve terrà la sua riunione sulla politica dei tassi di interesse il 17-18 settembre e, a meno che non si verifichino eventi imprevisti di rilievo, non c’è dubbio che la Fed inizierà il suo ciclo di riduzione dei tassi di interesse a settembre. Il problema sta nella portata dei tagli dei tassi. Secondo le valutazioni del mercato valutario, gli investitori ritengono attualmente che la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base a settembre sia di circa il 70%.</p>
<h3 id="h3-Conclusion123346"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>Nel complesso, il mercato si trova ancora in un periodo di volatilità e aggiustamento a breve termine, con le principali criptovalute come BTC ed ETH che mostrano prestazioni deboli e il sentiment nel mercato delle Altcoin che è lento. Gli investitori dovrebbero monitorare attentamente le variazioni dei principali livelli di supporto e resistenza, nonché l’impatto dei prossimi eventi di sblocco su larga scala di IMX e TAIKO sul mercato.</p>
<p>In uno stato continuo di paura nel sentiment di mercato e sotto l’influenza di molteplici fattori negativi, si consiglia agli investitori di rimanere cauti e di evitare di effettuare grandi transazioni in un ambiente di mercato altamente incerto. Nel frattempo, prestare attenzione alle potenziali opportunità di pesca in fondo, ma aspettare segnali di mercato più chiari prima di prendere decisioni.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>