Tm90aXppZSBxdW90aWRpYW5lIHwgJDkuMjUgbWlsaWFyZGkgZGkgb3B6aW9uaSBCVEMgc3Rhbm5vIHBlciBzY2FkZXJlOyBMYSBTRUMgcG90cmViYmUgYXBwcm92YXJlIGdsaSBFVEYgRXRoZXJldW0gc3BvdDsgSWwgdGVhbSBCVk0gaGEgbGFuY2lhdG8gaWwgc2Vydml6aW8gWksgUm9sbHVwcyBwZXIgZXNwYW5kZXJlIEJUQw==

2024-06-27, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17194601691_20.png" alt=""></p>
<h2 id="h2-Digest20quotidiano20di20criptovalute20le20opzioni20BTC20del20valore20di2092520miliardi20stanno20per20scadere20e20i20tori20potrebbero20affrontare20una20crisi20La20SEC20potrebbe20approvare20gli20ETF20Ethereum20spot20gi20il20420luglio20Il20team20Bitcoin20Virtual20Machine20ha20lanciato20il20servizio20ZK20Rollups20per20espandere20Bitcoin20I20drop20di20Blast20hanno20emesso201720miliardi20di20token302498"><a name="Digest quotidiano di criptovalute: le opzioni BTC del valore di $9,25 miliardi stanno per scadere e i tori potrebbero affrontare una crisi; La SEC potrebbe approvare gli ETF Ethereum spot già il 4 luglio; Il team Bitcoin Virtual Machine ha lanciato il servizio ZK Rollups per espandere Bitcoin; I drop di Blast hanno emesso 17 miliardi di token." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest quotidiano di criptovalute: le opzioni BTC del valore di $9,25 miliardi stanno per scadere e i tori potrebbero affrontare una crisi; La SEC potrebbe approvare gli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot già il 4 luglio; Il team <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Virtual Machine ha lanciato il servizio ZK Rollups per espandere Bitcoin; I drop di Blast hanno emesso 17 miliardi di token.</h2><p>Innanzitutto, 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 26 giugno, gli ETF spot Bitcoin di Grayscale (GBTC) hanno ricevuto un afflusso di 4,3 milioni di dollari; Nel frattempo, l’ETF Bitcoin spot di Fidelity (FBTC) ha avuto un afflusso di 18,6 milioni di dollari, e l’ETF spot Bitcoin ARK 21 Shares (ARKB) ha subito un deflusso di 4,9 milioni di dollari. Secondo i dati ufficiali di Grayscale, al 26 giugno, Grayscale GBTC deteneva 275.895,653 BTC, una diminuzione di circa 499,811 rispetto al giorno di negoziazione precedente.</p>
<p><strong>Opzioni BTC del valore di $9,25 miliardi scadono questa settimana, e i tori potrebbero trovarsi di fronte a una crisi</strong><br>La scadenza mensile di giugno è particolarmente cruciale poiché segna la fine del primo semestre del 2024. Da un punto di vista storico, questo momento rappresenta la seconda data di scadenza più importante in tutti i mercati, compreso quello finanziario tradizionale. Ora, la gigante tecnologica Nvidia, con un valore di mercato di 3 trilioni di dollari, è scesa del 12% dopo aver raggiunto un massimo storico il 20 giugno, e gli investitori sono particolarmente preoccupati.</p>
<p>Questa settimana scadranno le opzioni BTC da 9,25 miliardi di dollari. Sono passati due mesi dall’evento di halving di Bitcoin e il 57% delle scommesse rialziste è concentrato su 70.000 dollari o più. Tuttavia, le scarse performance del mercato nelle ultime due settimane hanno messo sotto pressione i rialzisti. Se Bitcoin rimane intorno a 61.500 dollari il 28 giugno, le opzioni BTC a 62.000 e 64.000 dollari non scadranno, mentre le opzioni put a 58.000 e 60.000 dollari scadranno.</p>
<p>Le dinamiche attuali del mercato finanziario sono simili al 2021, il che potrebbe indicare l’arrivo di un mercato ribassista. Il segnale include la crescente differenza tra l’indice S&amp;P 500 e gli indici ponderati per l’equità. La disponibilità dei contratti di opzione call e put il 28 giugno dipende dal prezzo di liquidazione. È necessaria una posizione long di Bitcoin di $64.000 per evitare perdite, e la posizione long ha urgentemente bisogno di mantenere un livello di supporto di $60.000 prima della sua scadenza il 28 giugno.</p>
<p><strong>La SEC potrebbe approvare il mercato spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF già dal 4 luglio</strong><br>Esecutivi del settore e altre fonti pertinenti hanno rivelato che la US Securities and Exchange Commission (SEC) potrebbe approvare gli ETF Ethereum spot già il 4 luglio. Poiché i negoziati tra le società di gestione patrimoniale e le agenzie di regolamentazione sono entrati nella fase finale, otto società di gestione patrimoniale, tra cui BlackRock e VanEck, stanno cercando l’approvazione della SEC per lanciare questi fondi.</p>
<p>Le fonti hanno indicato che la modifica dei documenti di distribuzione è progredita solo nella risoluzione di questioni minori. Un avvocato che ha collaborato con una certa società emittente ha anche affermato che si tratta solo di un’operazione di “lucidatura finale” e l’approvazione potrebbe richiedere non più di una o due settimane. L’analista ETF Eric Balchunas aveva in precedenza previsto l’approvazione già il 2 luglio.</p>
<p>Il fondo lanciato a gennaio per tenere traccia dei prezzi spot di Bitcoin è uno dei fondi più di successo nel mercato degli ETF, attirando circa 8 miliardi di dollari di asset. Alla fine di giugno, la dimensione dell’attivo di questi nove prodotti era vicina a 38 miliardi di dollari, ma la partecipazione di Grayscale Bitcoin Trust è diminuita a 17,8 miliardi di dollari e l’azienda ha anche convertito il suo Bitcoin Trust da 27 miliardi di dollari in un ETF.</p>
<p>La SEC ha rifiutato di commentare su questo. Il presidente della SEC, Gary Gensler, ha dichiarato in un’intervista a Reuters earlier this month che la data di lancio dipenderà in parte dalla velocità di risposta dell’emittente alle indagini regolamentari.</p>
<p><strong>Il team Bitcoin Virtual Machine ha lanciato il servizio ZK Rollups per espandere Bitcoin</strong><br>La settimana scorsa, BVM ha lanciato il servizio di prova a conoscenza zero BitZK, che migliora la scalabilità di Bitcoin consentendo agli utenti di creare riassunti e migrare applicazioni da Ethereum a Bitcoin. L’aumento di tali attività ha spinto più team di sviluppo a esplorare nuovi modi per ampliare Bitcoin e assorbire idee da altri progetti di blockchain.</p>
<p>La tariffa di accesso di BVM al suo servizio BitZK è di $99 o più al mese e ha accumulato un gruppo di utenti iniziali, tra cui Bitcoin Layer2 RWA Chain, POWD3R Blockchain e Octopus Bridge. La quota mensile copre i costi di memoria, CPU e storage correlati all’esecuzione del secondo livello di Bitcoin.</p>
<p>La Bitcoin Virtual Machine (BVM) è stata lanciata nel gennaio 2023 e, secondo il white paper del progetto, “BVM è una macchina a stati simile a una macchina virtuale Ethereum che utilizza Bitcoin come layer di dati per raggiungere un consenso a livello di trading. Questo approccio consente a BVM di agire come una macchina a stati universale, sfruttando la sicurezza e la disponibilità dei dati di Bitcoin senza protocolli di rete o consenso aggiuntivi.”</p>
<p>Questo protocollo mira a rendere la rete Bitcoin il più universale possibile ed è una delle diverse soluzioni di scalabilità di Bitcoin. La domanda di soluzioni di scalabilità è iniziata l’anno scorso quando sono stati lanciati protocolli come Ordinals e Runes, aumentando la domanda di spazio per i blocchi. Queste soluzioni hanno iniziato a ricevere attenzione, stimolando le attività on-chain nella rete Bitcoin.</p>
<p>La scalabilità di Bitcoin è sempre stata una sfida, sia attraverso l’aumento della dimensione dei blocchi che lo sviluppo di soluzioni di livello 2 scalabili. La prova a conoscenza zero è utilizzata nel settore delle blockchain per comprimere i dati ed è diventata la base per molti dei rollup più popolari su Ethereum.</p>
<p><strong>Iirdrops Blast emessi 17 miliardi di token</strong><br>La rete di scalabilità di Ethereum Layer 2 Blast ha distribuito 17 miliardi di token BLAST ai primi adottanti della sua rete alle 10:00 ora orientale di mercoledì.</p>
<p>Lo strumento di esplorazione della blockchain di Parsec Finance mostra che oltre il 35% dei BLAST distribuiti gratuitamente è stato reclamato nelle prime ore del lancio del token.</p>
<h2 id="h2-Tendenze20di20mercato20La20narrazione20Layer220sta20gradualmente20venendo20abbandonata20dal20mercato20gli20occhi20sono20puntati20sui20dati20sullinflazione20pubblicati20venerd719683"><a name="Tendenze di mercato: La narrazione Layer2 sta gradualmente venendo abbandonata dal mercato, gli occhi sono puntati sui dati sull’inflazione pubblicati venerdì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: La narrazione Layer2 sta gradualmente venendo abbandonata dal mercato, gli occhi sono puntati sui dati sull’inflazione pubblicati venerdì</h2><p>BTC: Bitcoin ha subito un calo dopo aver rimbalzato sopra i $62.000 ed attualmente si sta consolidando intorno ai $61.000. Questo stato di consolidamento indica che il mercato sta cercando nuove direzioni e gli investitori sono in attesa di ulteriori segnali di mercato.</p>
<p>ETH: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Ethereum</a> è leggermente sceso a circa $3.380; tuttavia, il tasso di cambio ETH/BTC rimane forte.</p>
<p>Altcoin: Dopo aver sperimentato la crescita generale di ieri, l’attuale aumento degli Altcoin si è ridotto. Questa situazione di solito indica che il mercato sta digerendo i guadagni precedenti e potrebbe esserci una domanda di regolazione a breve termine.</p>
<h3 id="h3-Macroeconomia1720"><a name="Macroeconomia:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia:</h3><p>Azioni statunitensi: Continuando a salire, indica la fiducia degli investitori nelle prospettive economiche. Ma allo stesso tempo, l’indice del dollaro statunitense sta aumentando. Il mercato è fortemente preoccupato per i prossimi dati sull’indice dell’inflazione che verranno pubblicati venerdì, i quali avranno un impatto significativo sulle future politiche monetarie.</p>
<h3 id="h3-Punti20Caldi20del20Mercato384008"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>Progetto Layer2 Blast: BLAST è stato lanciato su Gate la scorsa notte e attualmente ha una capitalizzazione di mercato di $2,7 miliardi. Il modello di distribuzione airdrop di Blast non è user-friendly per i grandi giocatori e non è ancora stato lanciato su piattaforme di trading di alta qualità. Le prestazioni dei prezzi di Blast, in qualche modo, indicano che il mercato sta abbandonando la narrazione di Ethereum Layer2 e gli investitori potrebbero essere alla ricerca di nuovi punti di crescita.</p>
<p>Elenco dei progetti di stablecoin: LISTA continua a salire, superando i $0.8 questa mattina. Questa settimana, Lista ha annunciato l’inizio di un nuovo round di mining, con LISTA/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Il ricavo annuale di mining di ’s raggiunge il 245%. Gli utenti della comunità stimano che in base al ricavo di mining di Lista, il picco di prezzo dei token LISTA potrebbe essere intorno a $1.2.</p>
<p>KAS della catena Pow: KAS è aumentato rapidamente, avvicinandosi a un massimo storico. L’annuncio ufficiale è che Kaspa Chain sposterà il suo focus verso le Meme coin in futuro. Dopo l’halving di BTC, molte aziende minerarie di BTC hanno spostato la loro potenza di calcolo per estrarre KAS.</p>
<p>Sezione meme: Trump e Biden terranno il loro dibattito presidenziale domani alle 21:00 ora di Pechino. I token concetto delle elezioni americane, come MAGA e PEOPLE, meritano attenzione e potrebbero subire fluttuazioni di prezzo a breve termine a causa dei dibattiti.</p>
<p>Dopo una fase di aggiustamento e consolidamento nel mercato attuale, gli investitori dovrebbero monitorare attentamente la pubblicazione dei dati macroeconomici e le variazioni delle tendenze di mercato. In particolare nel settore Meme, ci sono certe opportunità di investimento a breve termine. Per gli investitori a lungo termine, osservare le tendenze di BTC e ETH, così come le modifiche alle politiche macroeconomiche, aiuterà a sviluppare strategie di investimento più solide.</p>
<h2 id="h2-Macro20Trading20volatilit20prima20della20pubblicazione20dei20dati20sullinflazione20con20Wall20Street20che20chiude20leggermente20in20rialzo20le20borse20asiatiche20cadono20lo20yen20giapponese20precipita195556"><a name="Macro: Trading volatilità prima della pubblicazione dei dati sull’inflazione, con Wall Street che chiude leggermente in rialzo; le borse asiatiche cadono, lo yen giapponese precipita" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Trading volatilità prima della pubblicazione dei dati sull’inflazione, con Wall Street che chiude leggermente in rialzo; le borse asiatiche cadono, lo yen giapponese precipita</h2><p>Il 26 giugno, i principali indici azionari statunitensi hanno chiuso leggermente al rialzo mercoledì dopo una giornata di negoziazione volatile. Gli investitori rimangono cauti in attesa del dibattito presidenziale negli Stati Uniti e del tanto atteso rapporto sull’inflazione della Federal Reserve.</p>
<p>La performance dell’indice è la seguente: l’indice Dow Jones è aumentato dello 0,04%, l’indice Standard &amp; Poor’s è aumentato dello 0,16% e l’indice Nasdaq è aumentato dello 0,49%.</p>
<p>Il produttore di chip Nvidia è aumentato dello 0,25% prima della chiusura, attenuando la precedente flessione. Anche grandi aziende tecnologiche come Apple, Amazon e Tesla hanno registrato profitti. Tuttavia, alcuni analisti hanno manifestato preoccupazioni riguardo a Nvidia, affermando che le questioni geopolitiche potrebbero influire significativamente sull’azienda.</p>
<p>Questa settimana ci saranno diverse pubblicazioni di dati economici, tra cui l’indice dei prezzi della spesa per consumi personali (PCE) di venerdì, che è particolarmente importante ed è il principale indicatore di inflazione preferito dalla Federal Reserve per determinare il percorso della politica monetaria. Gli analisti ritengono che gli investitori siano ancora in attesa del dibattito presidenziale di domani e dei dati del PCE. Nel frattempo, gli investitori hanno aumentato le scommesse su settori non tecnologici all’inizio di questa settimana.</p>
<p>A causa delle preoccupazioni per l’inflazione, giovedì 27 giugno i mercati azionari asiatici sono scesi e i rendimenti dei bond sono aumentati. L’indice Nikkei in Giappone è sceso dell’1%, mentre l’indice azionario più ampio della regione Asia-Pacifico MSCI è sceso dello 0,5%.</p>
<p>Il rendimento USA ha sostenuto il dollaro USA nel mercato dei cambi, raggiungendo un massimo di due mesi di 106,13 contro un paniere di valute mercoledì. A causa dell’inflazione ostinata e dei dati economici solidi, le aspettative di tagli dei tassi di interesse negli Stati Uniti sono state sopite, con l’indice del dollaro USA in aumento del 1,3% questo mese e quasi dell’1,5% nel trimestre. Il dollaro neozelandese è sceso ulteriormente dello 0,1% giovedì a un minimo di sei settimane di $0,6069, mentre la sterlina è scesa a un minimo di sei settimane di $1,2613. Il dollaro USA ha toccato un massimo di sei settimane contro la sterlina e il dollaro di New York.</p>
<p>Il tasso di cambio dello yen giapponese rispetto al dollaro statunitense è di 160,7, leggermente inferiore al massimo di 38 anni registrato giovedì. Questo clima teso rende gli asset rischiosi nel mercato finanziario particolarmente vulnerabili.</p>
<p>Il yen giapponese è sceso a un minimo storico di 171,79 contro l’euro mercoledì, con lo yen contro il dollaro USA a 171,57 durante la sessione asiatica, inferiore al livello che ha spinto il Giappone a intervenire in aprile e maggio. Giovedì, il ministro delle Finanze giapponese Junichi Suzuki ha dichiarato che non avrebbe commentato il livello del tasso di cambio. Ha ribadito le preoccupazioni del governo sull’impatto della svalutazione dello yen sull’economia e monitora attentamente il mercato valutario.</p>
<p>L’accelerazione dell’inflazione al massimo di sei mesi nel mese di maggio ha influenzato il rendimento dei titoli di Stato australiani a tre anni, che sono aumentati di 18 punti base mercoledì. Giovedì sono saliti di 10 punti base al 4,21%, seguendo l’andamento delle vendite dei titoli di Stato statunitensi durante la notte.</p>
<p>Per quanto riguarda le materie prime, i futures del petrolio Brent sono scesi dello 0,4% a $ 84,92 al barile, in calo del 3% in questo trimestre.</p>
<p>A causa dell’aumento del rendimento, il prezzo dell’oro è sceso, scambiando a $2,297 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; 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 riposting dell'articolo a condizione che Gate.io venga citato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>