Tm90aXppZSBxdW90aWRpYW5lIHwgTGl0ZWNvaW4gdWZmaWNpYWxtZW50ZSBkaW1lenphdG8sIDYgYXppZW5kZSB0cmEgY3VpIEdyYXlzY2FsZSBoYW5ubyBwcmVzZW50YXRvIGRvbWFuZGEgcGVyIGdsaSBFVEYgZnV0dXJlcyBkaSBFdGhlcmV1bSwgaWwgS2VueWEgaGEgc29zcGVzbyBsJ29wZXJhemlvbmUgZGkgV29ybGRjb2luLCBGaXR

2023-08-03, 04:07

<p><img src="https://gimg2.gateimg.com/image/article/16910453210803.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Dopo20il20dimezzamento20di20Litecoin20il20mercato2020rimasto20silenzioso20e20sei20aziende20come20Grayscale20hanno20presentato20domanda20per20un20ETF20futures20su20Ethereum80808"><a name="Crypto Daily Digest: Dopo il dimezzamento di Litecoin, il mercato è rimasto silenzioso e sei aziende come Grayscale hanno presentato domanda per un ETF futures su Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Dopo il dimezzamento di Litecoin, il mercato è rimasto silenzioso e sei aziende come Grayscale hanno presentato domanda per un ETF futures su Ethereum</h2><p>Il 2 agosto, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ha dimezzato la ricompensa per blocco per la terza volta all’altezza del blocco di 2.520.000, da 12,5 LTC a 6,25 LTC.</p>
<p>Questo dimezzamento è il terzo dimezzamento di <a href="/price/litecoin-ltc" target="_blank" class="blog_inner_link">Litecoin</a> dal suo lancio nel 2011. Il primo dimezzamento ha avuto luogo nel 2015 e il secondo dimezzamento ha avuto luogo nel 2019.</p>
<p>Nel 2019, quando l’ultimo dimezzamento di Litecoin, il prezzo di Litecoin era di circa $90. Nel 2023, quando Litecoin è stato dimezzato, il prezzo della moneta era ancora di circa $90.</p>
<p>L’halving silenzioso, il mercato silenzioso e il sentiment del mercato che persino l’halving in un mercato orso non riesce a spingere devono aspettare fino a quando la fiducia del mercato si riprende, e il trend al rialzo potrebbe avere una risposta.</p>
<p>Eric Balchunas, analista senior degli ETF di Bloomberg, ha twittato che attualmente sei aziende stanno presentando domanda per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF futures. Oltre alla presentazione di Volatility Shares il 28 luglio ora locale, Bitwise, Roundhill, VanEck, Proshares e Grayscale hanno presentato una domanda per <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Futures ETF il 1° agosto ora locale. Il termine per la SEC di decidere sulla domanda di Volatility Shares è l’11 ottobre e il termine per prendere decisioni sulla domanda degli altri cinque Ethereum futures ETF è il 16 ottobre.</p>
<p>Gli Ethereum Futures ETF richiesti da sei società sono Ether Strategy ETF, Bitwise Ethereum Strategy ETF, Roundhill Ethereum Strategy ETF, Ethereum Strategy ETF, Proshares Short Ethereum Strategy ETF e Grayscale Ethereum Futures ETF (ETHG).</p>
<p>Secondo CoinDesk, il Ministero degli Interni del Kenya ha pubblicato una dichiarazione sulla sua pagina Facebook mercoledì affermando di aver sospeso l’operazione di Worldcoin. La dichiarazione firmata dal Ministro Kithure Kindiki afferma: “Il governo è preoccupato per le attività in corso di un’organizzazione che afferma di essere ‘WORLD COIN’, che raccoglie dati sull’occhio/iride per la registrazione dei cittadini.” I servizi finanziari, di sicurezza e di protezione dei dati pertinenti hanno avviato un’indagine per determinare la legalità e la protezione dei dati del progetto.</p>
<p>Il rivenditore di videogiochi GameStop ha dichiarato che smetterà di supportare i suoi portafogli cripto a causa di ‘incertezza regolamentare’. Secondo il sito web dell’azienda, GameStop rimuoverà i suoi portafogli iOS e Chrome Extension dal mercato il 1° novembre, che consente agli utenti di gestire le loro criptovalute e NFT. La mossa segna l’abbandono della strategia di criptovaluta da parte di GameStop.</p>
<p>La società ha dichiarato che non si concentrerà più sulle criptovalute dopo la perdita netta di $94,7 milioni nel terzo trimestre dello scorso anno e i licenziamenti nel dipartimento degli asset digitali. GameStop ha lanciato il mercato NFT un anno fa, consentendo ai giocatori, ai creatori, ai collezionisti e agli altri membri della comunità di acquistare, vendere e scambiare NFT.</p>
<p>Secondo i dati di vendita NFT monitorati da CryptoSlam su 21 blockchain, le vendite totali di NFT a luglio sono state di circa $492 milioni. Tra queste vendite, le vendite di NFT sulla catena Ethereum rappresentano il 55%, circa $270 milioni. La seconda blockchain più grande per le vendite di NFT è <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Chain, con un totale di $64.92 milioni; Seguono <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>($37.61 milioni), <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>($24,58 milioni), e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>($23.43 milioni).</p>
<p>Secondo i dati di Defillama, il TVL della rete Base è ora sceso a $6,96 milioni, una diminuzione dell’83% rispetto al picco di $41,2 milioni del 31 luglio, probabilmente a causa del ritiro della liquidità da parte del team del progetto meme token BALD e dell’incidente di hacking di LeetSwap.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi828383"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC558831"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1691045357BTC.png" alt=""><br>Dopo aver brevemente toccato i $30.000 ieri, è sceso al livello di $29.000. La strategia a breve termine continua a concentrarsi sulla sua trendline ascendente. Strategia di ingresso rialzista rischiosa: $28.550; strategia di ingresso ribassista rischiosa: $27.950 con continua osservazione fino al livello di $26.500.</p>
<h3 id="h3-ETH771156"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1691045375ETH.png" alt=""><br>Per raccomandazioni aggressive a breve termine, osservare se si stabilizza sopra il trend al rialzo. Se si mantiene stabile e continua a salire, può essere considerato un segnale per entrare in una posizione long. Per strategie conservative a breve termine, si sta ancora aspettando una rottura di $2.037 con un obiettivo continuo al rialzo di $2.358. Si noti che il trend attuale è ancora ribassista.</p>
<h3 id="h3-CRV907765"><a name="CRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CRV</h3><p><img src="https://gimg2.gateimg.com/image/article/1691045394CRV.png" alt=""><br>Il fondatore di Curve, Michael Egorov, ha partecipato a transazioni over-the-counter con valori variabili (per un totale di $14,5 milioni) per CRV, con un prezzo medio OTC di circa $0,4 per USD. Il CRV a breve termine mostra una rara struttura rialzista a “spalla ascendente” con obiettivi al rialzo a $0,608, $0,639 e $0,68 per USD.</p>
<h2 id="h2-Macro20Fitch20Ratings20declassa20il20rating20di20credito20degli20Stati20Uniti20potenzialmente20influenzando20i20mercati20finanziari20globali783538"><a name="Macro: Fitch Ratings declassa il rating di credito degli Stati Uniti, potenzialmente influenzando i mercati finanziari globali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fitch Ratings declassa il rating di credito degli Stati Uniti, potenzialmente influenzando i mercati finanziari globali</h2><p>Fitch, una delle tre più grandi agenzie di rating del credito al mondo, ha annunciato un declassamento del rating di credito degli Stati Uniti, diventando la notizia più importante nei mercati globali del capitale e nei mercati finanziari degli ultimi due giorni.</p>
<p>Fitch ha spiegato che il motivo principale per il declassamento del rating di credito degli Stati Uniti è dovuto al sempre più pesante debito e alla disfunzione politica degli Stati Uniti. Hanno declassato il rating di credito degli Stati Uniti di un gradino, passando dal precedente rating AAA a AA+.</p>
<p>Il declassamento del rating di credito ha un enorme impatto sul mercato globale del capitale perché i bond del tesoro USA svolgono un ruolo importante nel mercato globale. È considerato un titolo rifugio con quasi nessun rischio di rendimento ed è il titolo più affidabile al mondo.</p>
<p>Il governo degli Stati Uniti prende in prestito denaro per raccogliere molti fondi economici e sostenibili emettendo un’obbligazione del tesoro. Tuttavia, dopo che il rating del credito viene abbassato, il costo dei bond del tesoro degli Stati Uniti aumenterà e anche il costo del debito del governo degli Stati Uniti aumenterà, indebolendo la sua capacità di rifinanziamento e avendo un’enorme impatto sul mercato finanziario globale.</p>
<p>Tra le tre principali agenzie di rating a livello mondiale, S&amp;P ha declassato il rating del governo degli Stati Uniti di un gradino dal suo livello più alto già nel 2011. E un’altra agenzia di rating, Moody’s, continua a dare agli Stati Uniti il rating più elevato.</p>
<p>La risposta dell’amministrazione Biden a questo incidente ha enfatizzato due punti. In primo luogo, ritengono che la decisione di valutazione di Fitch sia arbitraria, poiché si basa su dati obsoleti e sembra sottovalutare i rischi della lotta politica e la migliorata capacità del governo degli Stati Uniti di prendersi cura di sé. In secondo luogo, l’amministrazione Biden ha dichiarato che prima di prendere questa decisione, Fitch ha avuto diverse comunicazioni con il governo degli Stati Uniti, ma riteneva che Fitch aderisse comunque alla sua decisione.</p>
<p>Per quanto riguarda le opinioni degli investitori e degli economisti, alcuni ritengono che un declassamento del rating ridurrà gradualmente la fiducia dei mercati finanziari globali nel credito del governo statunitense. Sebbene il mercato azionario possa essere in qualche modo influenzato, l’impatto non sarà così significativo come nel 2011, poiché la Federal Reserve ha già attuato aumenti dei tassi di interesse e ha spazio per abbassarli.</p>
<p>Tuttavia, a causa dell’importante aumento delle valutazioni di mercato, in particolare nel settore tecnologico, alcune persone sono preoccupate che un declassamento possa avere un maggiore impatto sul settore tecnologico sopravvalutato.</p>
<p>In generale, l’impatto del mercato sul declassamento del rating di credito degli Stati Uniti da parte di Fitch si intensificherà ulteriormente e richiederà un’osservazione tranquilla.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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 ripubblicare l'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>