Tm90aXppZSBxdW90aWRpYW5lIHwgRVRIIGhhIHJpcHJlc28sIE1lbWUgc2kgw6ggcmFmZm9yemF0bzsgSWwgbGFuY2lvIGRlZ2xpIEVURiBTcG90IEVUSCDDqCBzdGF0byByaXRhcmRhdG8gYSBjYXVzYSBkZWkgY29tbWVudGkgZGVsbGEgU0VDOyAyMSBTaGFyZXMgaGEgcHJlc2VudGF0byBpbCBmaWxlIFMtMSBwZXIgZ2xpIEVURiBTcG9

2024-07-01, 04:10

<p><img src="https://gimg2.gateimg.com/image/article/17198068411_2.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20lancio20degli20ETF20Ethereum20spot2020stato20ritardato20a20causa20dei20commenti20della20SEC202120Shares20ha20presentato20il20file20S120per20lETF20Solana20spot20Roaring20Kitty20ha20affrontato20accuse20di20frode20finanziaria20nelle20cause20relative20a20GME511973"><a name="Riepilogo giornaliero delle criptovalute: il lancio degli ETF Ethereum spot è stato ritardato a causa dei commenti della SEC; 21 Shares ha presentato il file S-1 per l’ETF Solana spot; Roaring Kitty ha affrontato accuse di frode finanziaria nelle cause relative a GME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il lancio degli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot è stato ritardato a causa dei commenti della SEC; 21 Shares ha presentato il file S-1 per l’ETF <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> spot; Roaring Kitty ha affrontato accuse di frode finanziaria nelle cause relative a GME</h2><p>In primo luogo, esaminiamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 28 giugno gli ETF spot Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (GBTC) hanno registrato deflussi di fondi pari a 27,2 milioni di dollari. Nel frattempo, gli ETF spot Bitcoin di Fidelity (FBTC) hanno registrato deflussi di 25 milioni di dollari, l’iShares Trust Bitwise Bitcoin spot ETF (IBIT) ha registrato un afflusso di 84,1 milioni di dollari e l’ARK 21Shares Bitcoin spot ETF (ARKB) ha registrato un afflusso di 42,8 milioni di dollari.</p>
<p><strong>Il lancio dello spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF è stato ritardato a causa dei commenti della SEC</strong><br>La Securities and Exchange Commission (SEC) degli Stati Uniti ha commentato il modulo S-1 e ha richiesto una nuova presentazione prima dell’8 luglio, il che ha ritardato il lancio dello spot Ethereum ETF fino a metà o fine luglio. Anche se molte persone si aspettano di lanciare gli ETF Ethereum già il 2 luglio, la SEC ha rinviato questo piano.</p>
<p>L’analista ETF Eric Balchunas ha affermato che questo nuovo programma significa che l’ETF Ethereum spot potrebbe essere lanciato a metà o fine luglio. Il presidente di ETF Store, Nate Geraci, ha sottolineato che la precedente revisione S-1 è stata piuttosto limitata e si prevede che la SEC approverà gli emittenti per il trading entro 14-21 giorni. Sebbene la tempistica esatta sia ancora incerta, la SEC ha indicato che potrebbe essere lanciata quest’estate.</p>
<p>L’approvazione del modulo S-1 è la seconda parte del processo a due fasi richiesto per l’elenco ETF. La prima parte prevede l’approvazione dei moduli 19b-4 presentati dall’emittente a maggio. Il 23 maggio, la SEC ha approvato i moduli 19b-4 per otto offerenti ETF.</p>
<p><strong>21 Shares ha presentato il file S-1 per spot <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF</strong><br>La società di investimento 21Shares ha presentato il modulo S-1 per Solana ETF alla Securities and Exchange Commission degli Stati Uniti, e il suo concorrente VanEck ha presentato un documento simile lo stesso giorno. Questa è la seconda volta che gli Stati Uniti presentano una domanda di ETF SOL in pochi giorni, il che conferma anche alcune previsioni degli analisti secondo cui la domanda di VanEck presentata il 27 giugno aprirà la porta ai concorrenti che cercano di lanciare fondi basati su Solana.</p>
<p>21 Shares, con sede a Zurigo, in Svizzera, gestisce un prodotto negoziato in borsa per lo staking fisico di Solana con un patrimonio gestito superiore a 846 milioni di dollari. Gestisce anche un ETF Bitcoin che è stato lanciato per il trading.</p>
<p>“21 Shares è entusiasta della possibilità che un ETF entri nell’ecosistema Solana negli Stati Uniti”, ha dichiarato Andrew Jacobson, direttore legale di 21 Shares. “Riteniamo che questo sia un passo necessario per l’industria delle criptovalute e si allinea alla nostra missione di lanciare prodotti finanziari facilmente accessibili incentrati sugli asset cripto.” Al momento della pubblicazione, il prezzo di negoziazione di SOL era di $147.58.</p>
<p>Il direttore della ricerca di VanEck ritiene che Ethereum presto lancerà la sua serie di ETF e che ora sia il momento migliore per approvare gli ETF SOL. Tuttavia, da un punto di vista pratico, potrebbe essere più difficile per gli ETF SOL superare il processo di revisione della SEC.</p>
<p><strong>Roaring Kitty ha affrontato accuse di frode sui titoli nelle cause relative a GME
</strong><br>Keith Gill, un trader di azioni noto per la stretta ribassista su GameStop nel 2021, ha affrontato accuse di frode sui titoli a causa di una serie di recenti post sui social media che hanno portato a significative fluttuazioni nei prezzi delle azioni di GameStop (GME) da maggio a giugno.</p>
<p>La causa è stata presentata il 28 giugno presso il distretto orientale di New York, con l’obiettivo di citare in giudizio Gill per aver pianificato un piano di “Pump and Dump” attraverso una serie di post sui social media a partire dal 13 maggio. Il reclamo afferma che Gill è colpevole di frode sui titoli e di non aver completamente divulgato l’acquisto e la vendita delle sue opzioni GameStop, sospettato di aver indotto in errore i suoi seguaci e di aver causato perdite a alcuni investitori.</p>
<p>Il querelante Martin Radev, rappresentato dallo studio legale Pomerantz, ha dichiarato che dal metà maggio ha acquistato un totale di 25 azioni GME e 3 opzioni di acquisto, subendo danni dal cosiddetto “Pump and Dump”.</p>
<p>In precedenza, Gill ha interrotto due anni di silenzio sui social media pubblicando una serie di emoji misteriose sul suo account X, facendo schizzare il prezzo delle azioni di GameStop del 180%. Alla chiusura del 14 maggio, il prezzo delle azioni è passato da $17,46 a $48,75. Al 13 giugno, Gill ha dichiarato di aver esercitato tutte le 120.000 opzioni, guadagnando milioni di dollari e utilizzando questi guadagni per aumentare ulteriormente la sua partecipazione nelle azioni di GameStop.</p>
<h2 id="h2-Tendenze20di20mercato20lapprovazione20dellETF20Ethereum20spot2020imminente20con20un20forte20rimbalzo20del20mercato139962"><a name="Tendenze di mercato: l’approvazione dell’ETF Ethereum spot è imminente, con un forte rimbalzo del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: l’approvazione dell’ETF Ethereum spot è imminente, con un forte rimbalzo del mercato</h2><p>BTC ha superato i $63.500 stamattina, un ostacolo psicologico e tecnico importante. La forte performance di Bitcoin di solito fa aumentare l’intero mercato delle criptovalute. Dal punto di vista dell’analisi tecnica, se ci mantenessimo saldi a quota $63.500, il prossimo obiettivo potrebbe essere $65.000 o anche superiore.</p>
<p>Anche ETH ha superato la soglia dei $3.500 questa mattina. La forte performance di Ethereum è dovuta non solo alla sua posizione come seconda criptovaluta per valore di mercato, ma anche all’espansione continua del suo ecosistema e all’aumento delle applicazioni. $3.500 rappresenta un livello di resistenza importante, e se riesce a superarlo e stabilizzarsi, potrebbe salire ulteriormente a $3.700 o addirittura $4.000.</p>
<p>Le altcoin generalmente riprendono con il mercato complessivo, specialmente nella forte performance di Bitcoin ed Ethereum. Le altcoin hanno di solito una maggiore volatilità e potenziale rialzista. Questo perché i fondi <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> in token più piccoli dal mercato, cercando rendimenti più elevati.</p>
<h3 id="h3-Macroeconomia231562"><a name="Macroeconomia:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia:</h3><p>Declino del mercato azionario USA: sebbene i dati PCE rilasciati lo scorso venerdì fossero in linea con le aspettative, il mercato ha già digerito in anticipo i dati CPI e PPI, e i dati PCE non hanno cambiato il modello di mercato rialzista o ribassista del mercato azionario USA. Le prestazioni del mercato azionario USA hanno un certo impatto sul mercato delle criptovalute, ma attualmente l’indipendenza del mercato delle criptovalute diventa sempre più forte.</p>
<h3 id="h3-Punti20caldi20del20mercato164473"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p><strong>Ecosistema ETH:</strong><br>ENS e SSV: con il forte rimbalzo di ETH, questi progetti dell’ecosistema Ethereum sono aumentati di oltre il 20%. ENS (Servizio di Nomi di Dominio Ethereum) e SSV (Protocollo di Staking) sono importanti componenti dell’ecosistema Ethereum, riflettendo la fiducia del mercato nel passaggio degli ETF spot Ethereum.</p>
<p>La SEC denuncia Consensys: La SEC statunitense ha annunciato una causa legale contro il team di sviluppo di Metamak, Consensys, e ha dichiarato che i progetti di staking come LDO e RPL appartengono a titoli. Ciò potrebbe avere un impatto negativo a breve termine su questi progetti.</p>
<p><strong>Settore dei meme:</strong><br>Le monete Meme della catena Solana come MOTHER e POPCAT hanno registrato un aumento di oltre il 30%. Grazie alle loro caratteristiche di trading veloci e a basso costo, le monete Meme sulla catena Solana hanno attirato una grande quantità di fondi speculativi.</p>
<p>Le monete Meme politiche su Ethereum: MAGA è risalito di oltre il 25%. Le monete Meme politiche sono soggette a significative fluttuazioni guidate da eventi o notizie specifiche.</p>
<p>Le criptovalute di tipo Meme a tema gatto: MOG è tornato al livello di $0,000002, a un solo passo dal nuovo massimo.</p>
<p><strong>Sblocco del token:</strong><br>Principale token WLD nel settore dell’IA: A partire dal 24 luglio, WLD sbloccherà quasi 20 milioni di token al giorno per un periodo di due anni. Lo sblocco continuo dei token porterà pressione venditrice sul mercato e gli investitori devono essere cauti, in particolare concentrandosi sulle fluttuazioni di prezzo durante il periodo di sblocco.</p>
<p>Le prestazioni complessive del mercato attuale sono forti, specialmente le innovazioni in Bitcoin ed Ethereum, che hanno portato fiducia all’intero mercato. Tuttavia, gli investitori devono ancora monitorare i dati macroeconomici e la dinamica normativa, che potrebbero avere impatti a breve termine sul mercato. Nella scelta degli obiettivi di investimento, gli investitori dovrebbero concentrarsi su progetti di alta qualità all’interno degli ecosistemi di Solana ed Ethereum, stando attenti alle monete Meme ad alto rischio e ai token che sono in procinto di affrontare una grande quantità di sblocco e pressione di vendita.</p>
<h2 id="h2-Macro20Il20mercato20sta20digerendo20i20dati20sullinflazione20lindice20di20Wall20Street2020in20calo20lapertura20del20mercato20asiatico2020lenta159712"><a name="Macro: Il mercato sta digerendo i dati sull’inflazione, l’indice di Wall Street è in calo; l’apertura del mercato asiatico è lenta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato sta digerendo i dati sull’inflazione, l’indice di Wall Street è in calo; l’apertura del mercato asiatico è lenta</h2><p>Venerdì 28 giugno, mentre gli investitori digerivano i dati sull’inflazione attesa e valutavano l’incertezza politica dopo il dibattito presidenziale negli Stati Uniti, i guadagni iniziali del mercato azionario statunitense si sono gradualmente indeboliti e hanno chiuso al ribasso venerdì.</p>
<p>Le performance dell’indice sono le seguenti: l’indice Dow Jones è sceso dello 0,11%, l’indice Standard &amp; Poor’s è sceso dello 0,41% e l’indice Nasdaq è sceso dello 0,71%. Nell’indice S&amp;P 500, i settori dell’energia e dell’immobiliare hanno registrato le migliori performance, con un aumento rispettivamente dello 0,42% e dello 0,62%; le azioni delle pubbliche utility e dei servizi di comunicazione sono invece diminuite dello 1,08% e del 1,63%.</p>
<p>I dati mostrano che il tasso di inflazione mensile negli Stati Uniti è rimasto invariato a maggio, il che rappresenta un progresso incoraggiante fatto all’inizio di quest’anno dopo forti aumenti dei prezzi che hanno sollevato dubbi sull’efficacia della politica monetaria della Federal Reserve. Il rapporto del Ministero del Commercio mostra anche che la spesa dei consumatori è leggermente aumentata il mese scorso, il che migliora la situazione delle persone. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> sulla banca centrale degli Stati Uniti che raggiunge un “atterraggio morbido” nell’economia.</p>
<p>Secondo i dati di Federal Watch della Borsa di Londra, il mercato si aspetta che la probabilità di un taglio dei tassi a settembre aumenti al 66% dopo la pubblicazione dell’indice dei prezzi delle spese dei consumatori personali. Nonostante la Federal Reserve preveda di tagliare i tassi di interesse solo una volta quest’anno, i trader scommettono ancora su due tagli dei tassi, aspettandosi che l’inflazione continui a raffreddarsi.</p>
<p>Lunedì 1 luglio, il mercato asiatico ha aperto una nuova settimana, trimestre e semestre di negoziazione, con gli investitori concentrati sull’agenda economica ricca di dati.</p>
<p>Nel complesso, i mercati azionari asiatici hanno registrato una debolezza lunedì mentre gli operatori si concentravano sulle prospettive dei tassi di interesse negli Stati Uniti. Allo stesso tempo, l’euro è salito poiché nel primo turno delle elezioni anticipate in Francia, i partiti di destra hanno vinto nonostante un’affluenza inferiore rispetto a quanto previsto da alcuni sondaggi. L’euro è salito dello 0,32%, i futures sull’indice azionario europeo sono saliti dell’1% e i futures sulle obbligazioni francesi OAT sono saliti dello 0,15% mentre gli investitori hanno digerito risultati migliori del previsto, anche se permane ancora dell’incertezza.</p>
<p>Il rapporto sull’Indice dei direttori agli acquisti del settore manifatturiero Caixin di giugno rifletterà la situazione attuale in Cina. Gli investitori sperano di vedere una forte crescita, ma i risultati mostrano una crescita economica disomogenea, persistenti rischi deflazionistici e un enorme pressione sul mercato azionario e sul tasso di cambio, che richiedono ulteriori misure di stimolo.</p>
<p>Il PMI manifatturiero pubblicato dal Bureau nazionale di statistica della Cina domenica è stato pari a 49,5, invariato rispetto a maggio, segnando il secondo mese consecutivo di declino dell’attività manifatturiera. L’indice PMI del settore dei servizi è sceso a 50,2, un nuovo minimo di 5 mesi, mentre l’indice PMI del settore delle costruzioni è sceso a 52,3, il livello più basso da luglio dello scorso anno. Tutti questi dati indicano una crescita economica, ma a un ritmo più lento.</p>
<p>L’indice PMI manifatturiero per diversi altri paesi asiatici, tra cui Giappone, India, Corea del Sud e Australia, sarà pubblicato lunedì.</p>
<p>L’indice azionario MSCI Asia Pacific è salito dello 0,07%, mentre l’indice Nikkei in Giappone è salito dello 0,57%. Il mercato azionario cinese è sceso, con le blue chip in calo dello 0,45%. L’indice Hang Seng di Hong Kong è rimasto invariato.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono leggermente aumentati, con i futures del Brent in rialzo dello 0,39% a $85,33 al barile, e i futures del petrolio greggio West Texas Intermediate negli Stati Uniti in aumento dello 0,42% a $81,88 al barile.</p>
<p>L’oro spot è salito dello 0,1% a $2.327,12 l’oncia. I prezzi dell’oro sono aumentati di oltre il 4% nel secondo trimestre. I futures sull’oro statunitense sono scesi dello 0,1% a $2.336,60.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</strong>, Ricercatore 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, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>