Tm90aXppZSBxdW90aWRpYW5lIHwgR2xpIEVURiBCVEMgaGFubm8gcmVnaXN0cmF0byBzaWduaWZpY2F0aXZpIGRlZmx1c3NpLCBpIERPR1MgaGFubm8gbW9zdHJhdG8gbGEgbWlnbGlvcmUgcGVyZm9ybWFuY2UgbmVsIGRlY2xpbm8gZGkgbWVyY2F0bw==

2024-08-28, 05:31

<p><img src="https://gimg2.gateimg.com/image/article/172482293028.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Gli20ETF20di20BTC20hanno20registrato20significative20uscite20Maker20ha20lanciato20il20token20di20governance20SKY560869"><a name="Crypto Daily Digest: Gli ETF di BTC hanno registrato significative uscite, Maker ha lanciato il token di governance SKY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Gli ETF di BTC hanno registrato significative uscite, Maker ha lanciato il token di governance SKY</h2><p>Secondo i dati degli investitori di Farside, c’è stata un deflusso netto di 127,05 milioni di dollari dal mercato spot statunitense <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF ieri hanno interrotto gli otto giorni consecutivi di afflussi netti. Ieri, ARKB ha registrato un deflusso netto di 102 milioni di dollari, GBTC ha registrato un deflusso netto di 18,3 milioni di dollari e BITB ha registrato un deflusso netto di 6,8 milioni di dollari.</p>
<p>Ieri c’è stato un deflusso netto di 3,44 milioni di dollari dallo spot statunitense <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF, senza flussi di ingresso/uscita da BlackRock ETHA, un deflusso netto di $9,18 milioni da Grayscale ETHE e un afflusso netto di $3,88 milioni da Fidelity FETH. Bitwise ETHW ha avuto un afflusso netto di $1,86 milioni.</p>
<p><strong>Analista: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> potrebbe raggiungere $150.000 entro la fine del 2024</strong></p>
<p>Jamie Coutts, Chief Crypto Analyst presso Real Vision, ha affermato che “a meno che non ci sia un cambiamento fondamentale”, il trend del prezzo di Bitcoin è ancora previsto entrare in una “stagione pazza”, nota anche come “zona banana”. Questo termine è stato coniato dal fondatore di Real Vision, Raoul Pal, per riferirsi a un ciclo di rifinanziamento del debito guidato dalle forze macroeconomiche che influisce su tutti i prezzi degli asset, ma la performance delle criptovalute è particolarmente eccezionale.</p>
<p>Coutts ha osservato che nei primi due cicli di mercato rialzista, Bitcoin ha raggiunto nuovi massimi storici entro 365 giorni dal picco dell’indice locale del dollaro statunitense. Ha suggerito che se Bitcoin segue il modello del precedente mercato rialzista, il suo prezzo potrebbe aumentare di oltre il 100% rispetto al livello attuale e raggiungere i 150.000 dollari entro la fine del 2024.</p>
<p><strong>Rapporto CoinGecko: il token del settore PolitiFi supera il coin Meme quest’anno</strong></p>
<p>La piattaforma di aggregazione dati sulle criptovalute CoinGecko ha pubblicato un rapporto che afferma che dal 1° gennaio al 25 agosto 2024, la categoria di token PolitiFi (memi correlati alle figure delle elezioni negli Stati Uniti) è aumentata del 782,4%, superando la categoria più ampia delle monete meme, che è aumentata del 90,2% nello stesso periodo.</p>
<p>Anche se i token PolitiFi hanno ottenuto risultati migliori rispetto ai token Meme, sono comunque molto indietro rispetto a questi ultimi. Al 25 agosto, il settore PolitiFi ha una quota di mercato del 1,5% nella categoria delle monete Meme, con un valore di mercato di 680,8 milioni di dollari, mentre il valore di mercato delle monete Meme è di 45,6 miliardi di dollari.</p>
<p><strong>Il marchio Maker è stato rinominato Sky Protocol e lancerà il token di governance nativo SKY</strong></p>
<p>Il 27 agosto, secondo Cointelegraph, il protocollo Maker ha ufficialmente cambiato il suo nome in Sky e ha annunciato i nomi della sua stablecoin aggiornata e del token di governance nativo, con l’obiettivo di rendere le finanze decentralizzate (DeFi) più accessibili al pubblico. Come parte del cambio di nome, Maker ha ribattezzato la stablecoin decentralizzata più grande del mondo, Dai (DAI), in USDS.</p>
<p>Il protocollo introduce anche il token di governance nativo Sky (SKY) per un ecosistema Sky più ampio, come una versione migliorata del token Maker (MKR). Il co-fondatore di MakerDAO, Rune Christensen, ha dichiarato che questa rinominazione è un passo verso l’accoglienza della ‘prossima evoluzione di DeFi’. I detentori di MKR possono aggiornare il loro MKR a SKY e SKY può anche essere convertito nuovamente in MKR. L’aggiornamento è facoltativo. Gli utenti possono scambiare 24.000 SKY per ogni MKR durante il processo di aggiornamento.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020crollato20e20non20ci20sono20punti20caldi20per20le20Altcoin755532"><a name="Tendenze di mercato: il mercato è crollato e non ci sono punti caldi per le Altcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è crollato e non ci sono punti caldi per le Altcoin</h2><h3 id="h3-Monete20principali319808"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>Il BTC è sceso bruscamente a circa $58.000 ieri, e dopo due giorni consecutivi di afflussi superiori a $200 milioni, i BTC ETF hanno registrato un grande deflusso ieri. Non c’è altra spiegazione per la tendenza di mercato, e in generale, il mercato è avanti rispetto alle notizie;</p>
<p>Le prestazioni di ETH rimangono deboli, scendendo al di sotto di $2.400 in un punto. Il volume di trading di ETH ETF è debole e non vi è stato un grande afflusso di capitale positivo dal suo lancio;</p>
<p>Le altcoin sono generalmente crollate bruscamente, e il mercato è tranquillo.</p>
<h3 id="h3-Indicatori20di20dati313228"><a name="Indicatori di dati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indicatori di dati</h3><p>L’indice AHR999 è 0.65 oggi, e il prezzo attuale è ancora adatto agli investitori a lungo termine di BTC per investire. L’indice della paura e dell’avidità è 30, indicando che il sentiment di mercato è tornato alla fase della paura. Questo di solito significa che potrebbero esserci alcune opportunità per il mercato di acquistare in fondo, ma dovrebbe essere esercitata anche cautela.</p>
<h3 id="h3-Hotspot20di20mercato930330"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Ecosistema Ton: TON continua a cadere e la notizia dell’arresto di Durov è ancora in fermentazione. Molti personaggi famosi, tra cui Musk, hanno chiesto il salvataggio di Durov e sono emersi molti token concettuali di Durov sul mercato, ma tutti hanno avuto una scarsa performance. Dopo il lancio di DOGS, il prezzo è rimasto intorno a $0,00125. Nonostante il generale ribasso del mercato, il prezzo è rimasto stabile e la capitalizzazione di mercato circolante attuale di DOGS è di circa $650 milioni. Ciò dimostra la relativa stabilità di DOGS nell’attuale ambiente di mercato, che merita l’attenzione degli investitori.</p>
<h2 id="h2-Macroeconomia20i20tre20principali20indici20azionari20statunitensi20aumentano20leggermente20mentre20i20rendimenti20dei20titoli20di20Stato20statunitensi20continuano20a20diminuire261430"><a name="Macroeconomia: i tre principali indici azionari statunitensi aumentano leggermente, mentre i rendimenti dei titoli di Stato statunitensi continuano a diminuire" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: i tre principali indici azionari statunitensi aumentano leggermente, mentre i rendimenti dei titoli di Stato statunitensi continuano a diminuire</h2><p>I tre principali indici del mercato azionario statunitense hanno chiuso collettivamente in rialzo, con l’indice S&amp;P 500 che è salito dello 0,16% a 5.625,80 punti; Il Dow Jones Industrial Average è salito dello 0,02% a 41.250,50 punti; L’indice Nasdaq è salito dello 0,16% a 17.754,82 punti. Inoltre, il rendimento del benchmark del Tesoro decennale è del 3,83%, e il rendimento del Tesoro a 2 anni, che è il più sensibile al tasso di politica della Fed, è del 3,83%.</p>
<p>Dopo che il presidente della Federal Reserve, Powell, ha rilasciato la più forte chiamata finora per tagliare i tassi di interesse, sembra che il taglio dei tassi sia già stato deciso. Secondo il “FedWatch” della CME, la probabilità che la Federal Reserve tagli i tassi di interesse di 25 punti base a settembre è del 66%, e la probabilità di tagliare i tassi di interesse di 50 punti base è del 34%.</p>
<h3 id="h3-Conclusione116769"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>Il mercato attuale mostra un chiaro senso di paura, con i prezzi delle principali criptovalute e Altcoin generalmente in caduta. Tuttavia, asset individuali come BTC e DOGS mostrano un certo grado di resistenza al declino sotto specifiche circostanze, il che vale la pena di focalizzare per gli investitori a lungo termine. I cambiamenti nell’ambiente macroeconomico, come i possibili tagli dei tassi di interesse della Federal Reserve, potrebbero anche portare nuove opportunità al mercato. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<p>Gli investitori devono rimanere cauti nell’attuale ambiente di mercato, monitorare il sentiment del mercato e la dinamica macroeconomica e adeguare tempestivamente le loro strategie di investimento. Per gli investitori a lungo termine, il livello attuale dei prezzi e il sentiment del mercato potrebbero offrire alcune opportunità di investimento, ma è comunque necessaria prudenza per evitare esposizioni eccessive al rischio.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>