Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGUgRVRGIG9zY2lsbGFubywgbGUgYWx0Y29pbiBjcm9sbGFubzsgU29sYW5hIGNvbnRyYXN0YSBnbGkgYXR0YWNjaGkgZGVpIHZhbGlkYXRvcmkgc2FuZHdpY2g7IEZpZGVsaXR5IHRva2VuaXp6YSBpIGZvbmRpIGRlbCBtZXJjYXRvIG1vbmV0YXJpbyBzdWxsYSBibG9ja2NoYWluIGRpIEpQTW9

2024-06-11, 03:59

<p><img src="https://gimg2.gateimg.com/image/article/17180851261_7.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20BTC20fluisce20per20220miliardi20di20USD20acquisti20istituzionali20ETH20pi20alti20da20marzo20Solana20combatte20gli20attacchi20dei20validatori20sandwich20Fidelity20tokenizza20i20fondi20del20mercato20monetario20su20blockchain20JP20Morgan160102"><a name="Riepilogo giornaliero delle criptovalute: BTC fluisce per 2 miliardi di USD, acquisti istituzionali ETH più alti da marzo; Solana combatte gli attacchi dei validatori sandwich; Fidelity tokenizza i fondi del mercato monetario su blockchain JP Morgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: BTC fluisce per 2 miliardi di USD, acquisti istituzionali ETH più alti da marzo; <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> combatte gli attacchi dei validatori sandwich; Fidelity tokenizza i fondi del mercato monetario su blockchain JP Morgan</h2><p>Innanzitutto, analizziamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Secondo i dati di Farside Investor, gli ETF, il Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) ha registrato deflussi sostenuti di 39,5 milioni di dollari il 10 giugno, mentre il Fidelity Bitcoin Spot ETF (FBTC) ha visto deflussi di 3,0 milioni di dollari, il Bitwise Bitcoin Spot ETF (BITB) ha registrato ingressi di 7,6 milioni di dollari e l’Invesco Galaxy Bitcoin ETF (BITB) ha registrato ingressi di 7,6 milioni di dollari. (BITB) ingressi di 7,6 milioni di dollari e Invesco Galaxy Bitcoin Spot ETF (BTCO) deflussi di 20,5 milioni di dollari.</p>
<p>La società di gestione patrimoniale CoinShares ha dichiarato in un rapporto lunedì che i prodotti di investimento in criptovalute hanno attratto quasi 2 miliardi di dollari di afflussi la scorsa settimana, spingendo il mercato degli investimenti in criptovalute al rialzo per la quinta settimana consecutiva. Gli afflussi totali sono stati superiori a 4,3 miliardi di dollari.</p>
<h3 id="h3-Solana20intensifica20la20lotta20agli20attacchi20dei20validatori20a20sandwich591849"><a name="Solana intensifica la lotta agli attacchi dei validatori a sandwich" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana intensifica la lotta agli attacchi dei validatori a sandwich</h3><p>Un gruppo di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>(SOL) i verificatori stanno affrontando sanzioni finanziarie per aver presumibilmente facilitato attacchi finanziari contro i trader di criptovalute. Fonti hanno riferito che più di 30 validatori sono stati rimossi dal programma di delega della Fondazione Solana durante il fine settimana. Anche se rimangono verificatori nella rete, non sono più idonei a ricevere ricompense per la verifica delle transazioni della blockchain Solana.</p>
<p>Gli attacchi sandwich prevedono di effettuare un ordine prima di una transazione e un altro immediatamente dopo la transazione. Gli attaccanti imposteranno la prima transazione in sospeso tra transazioni front-end e back-end simultanee per manipolare il prezzo dell’asset e trarre profitto dalla differenza. Tim Garcia, responsabile delle relazioni con i verificatori presso Solana, ha annunciato su Discord che avrebbe rimosso i verificatori, affermando che “la partecipazione a un pool privato di memoria per effettuare attacchi sandwich o compromettere in altro modo l’integrità degli utenti di Solana non sarà delegata”.</p>
<p>Un post sulla governance della Fondazione Jito pubblicato domenica ha rivelato che il 10% del pool JitoSOL è delegato ai validatori che gestiscono pool di memoria privata. La Fondazione Jito sta proponendo di imporre ulteriori sanzioni finanziarie a questi validatori limitando ulteriormente i SOL promessi.</p>
<h3 id="h3-Fidelity20tokenizza20i20fondi20del20mercato20monetario20sulla20blockchain20di20JP20Morgan263989"><a name="Fidelity tokenizza i fondi del mercato monetario sulla blockchain di JP Morgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fidelity tokenizza i fondi del mercato monetario sulla blockchain di JP Morgan</h3><p>Il gestore di fondi britannico Fidelity International si è unito alla Tokenized Collateral Network (TCN) di JPMorgan e si è associato a Onyx Digital Assets per testare la tokenizzazione dei suoi fondi di mercato monetario (MMF). La connessione tra l’agente di trasferimento del fondo e la Tokenized Collateral Network ha permesso una tokenizzazione quasi istantanea.</p>
<p>La tokenizzazione si riferisce alla creazione di un veicolo di investimento virtuale sulla blockchain che rappresenta asset del mondo reale come immobili, metalli preziosi e oggetti da collezione. Si applica anche a azioni e obbligazioni. La tokenizzazione degli asset finanziari tradizionali è diventata una priorità assoluta per le banche e JP Morgan ci sta lavorando da anni.</p>
<p>Fidelity International ha una lunga storia nel settore degli asset digitali, recentemente ha collaborato con la banca svizzera Sygnum in un progetto di tokenizzazione nel marzo scorso. Lo scorso ottobre, JPMorgan Chase ha effettuato la prima transazione di regolamento di garanzia basata su blockchain in tempo reale, coinvolgendo azioni tokenizzate del BlackRock Money Market Fund. Queste azioni sono state trasferite a Barclays come garanzia per un’operazione di trading di derivati OTC. BlackRock ha abbracciato la tokenizzazione attraverso il suo progetto pubblico BUIDL con la società di servizi di tokenizzazione Securitize.</p>
<p>Stephen Whyman, responsabile dei mercati dei capitali di debito presso Fidelity International, ha dichiarato in un’intervista via email: “Tokenizzare le nostre quote del fondo di mercato monetario per usarle come garanzia è un passo importante e naturale nell’espandere la nostra adozione di questa tecnologia. I vantaggi per i nostri clienti e per il sistema finanziario in generale sono chiari; in particolare, un aumento dell’efficienza nel soddisfare i requisiti di margine e una riduzione dei costi di transazione e del rischio operativo.”</p>
<h2 id="h2-Tendenze20di20mercato20BTC20oscilla20a20livelli20elevati20mentre20in20generale20le20Altcoin20scendono868421"><a name="Tendenze di mercato: BTC oscilla a livelli elevati mentre in generale le Altcoin scendono" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC oscilla a livelli elevati mentre in generale le Altcoin scendono</h2><p><strong>BTC</strong>: Dopo aver superato i $70.000 questa mattina, c’è stato un ritracciamento ed ora si sta consolidando intorno ai $69.400. Nel breve termine, probabilmente oscillerà nell’intervallo di $68.000-$70.000, in attesa dei dati CPI di questa settimana per scegliere un nuovo movimento di mercato.</p>
<p><strong>ETH</strong>: Attualmente oscillante intorno a $3,660 con un trend relativamente stabile. Probabilmente fluttuerà nel breve termine nell’intervallo di $3,600-3,700.</p>
<p><strong>Altcoin</strong>: generalmente in calo, il sentiment di mercato è relativamente freddo. Gli investitori devono scegliere attentamente e prestare attenzione agli hotspot di mercato e alle monete individuali forti.</p>
<h3 id="h3-Macroeconomia129334"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p><strong>Azioni statunitensi in rialzo</strong>: Gli investitori sono in attesa della pubblicazione dei dati dell’indice dei prezzi al consumo (IPC) mercoledì, ci si aspetta che abbiano un grosso impatto sul mercato.</p>
<p><strong>dati CPI</strong> I dati sull’IPC sono un importante indicatore economico che potrebbe influenzare le aspettative del mercato sull’inflazione e sulla politica monetaria, influenzando quindi il trend del mercato delle criptovalute.</p>
<h3 id="h3-Hotspot20di20mercato486345"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p><strong>MADRE</strong>: Questa moneta ha guadagnato il 20% durante la giornata quando Iggy ha annunciato che MOTHER potrà essere utilizzata per pagare le bollette del telefono in futuro, aumentando gli scenari di utilizzo e attirando l’attenzione del mercato.</p>
<p><strong>BRETT</strong>: Meme coin su Base chain, capitalizzazione di mercato superiore a $1,6 miliardi, forte performance.</p>
<p><strong>BZZ</strong>: Uno dei principali token nel settore dello storage dell’ultimo mercato rialzista, con guadagni intraday di oltre il 50%. Con una capitalizzazione di mercato circolante attuale di $32 milioni e un ranking di capitalizzazione di mercato di 950, mostra un forte slancio di ripresa.</p>
<h3 id="h3-Token20sbloccato288185"><a name="Token sbloccato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token sbloccato:</h3><p><strong>STRK</strong>: La rete Ethernet Layer2 sbloccherà $ 80 milioni di token questa settimana. Lo sblocco di una grande quantità di token potrebbe portare a una volatilità di mercato, e gli investitori dovrebbero prestare attenzione ai movimenti di mercato prima e dopo lo sblocco.</p>
<h3 id="h3-Avviso20di20rischio288669"><a name="Avviso di rischio:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avviso di rischio:</h3><p>Il mercato delle criptovalute è volatile, gli investitori devono essere cauti e evitare di inseguire i massimi.<br>Presta attenzione ai dati macroeconomici, come i dati sull’IPC, che potrebbero influenzare maggiormente il mercato.<br>Presta attenzione ai cambiamenti nel sentiment di mercato e adatta le strategie di investimento tempestivamente.</p>
<h2 id="h2-Macro20SampP2050020e20Nasdaq20raggiungono20nuovi20massimi20di20chiusura20Riunione20della20Fed20e20CPI20in20arrivo174309"><a name="Macro: S&amp;P 500 e Nasdaq raggiungono nuovi massimi di chiusura; Riunione della Fed e CPI in arrivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: S&amp;P 500 e Nasdaq raggiungono nuovi massimi di chiusura; Riunione della Fed e CPI in arrivo</h2><p>Lunedì 10 giugno, Reuters ha riportato che l’S&amp;P 500 e il Nasdaq hanno ancora raggiunto nuovi massimi di chiusura lunedì nonostante la cautela degli investitori in vista del prossimo rapporto sull’indice dei prezzi al consumo (CPI) di questa settimana e della dichiarazione di politica della Federal Reserve.</p>
<p>Per quanto riguarda gli indici specifici, il Dow Jones è salito dello 0,2 percento, l’indice S&amp;P 500 è salito dello 0,3 percento e il Nasdaq è salito dello 0,4 percento.</p>
<p>Nvidia, che ha trainato Nasdaq e S&amp;P 500 verso l’alto, ha chiuso in rialzo dello 0,7 percento dopo uno split azionario di dieci azioni. Alcuni investitori ritengono che il produttore di chip sarà probabilmente incluso nei titoli blu del Dow Jones.</p>
<p>Il rapporto sull’indice dei prezzi al consumo di maggio verrà pubblicato mercoledì, quando si concluderà la riunione di politica della Federal Reserve di due giorni. La Fed pubblicherà le sue ultime proiezioni economiche e di politica e si prevede che lasci i tassi di interesse invariati. Gli investitori presteranno attenzione a indizi su quando la Fed inizierà a tagliare i tassi.</p>
<p>Martedì 11 giugno, i mercati asiatici sembrano destinati a continuare ad essere frenati dall’aumento dei rendimenti obbligazionari, dalle turbolenze politiche in Europa, da un dollaro statunitense più forte e dalla cautela in vista della decisione della Federal Reserve più avanti nella settimana.</p>
<p>Tuttavia, l’economia del Giappone ha iniziato la settimana con una nota positiva, sostenuta dalle revisioni al rialzo superiori alle aspettative del PIL del primo trimestre e da un declino complessivo dello yen per i rendimenti dei titoli di Stato giapponesi.</p>
<p>I principali dati economici di martedì consistono principalmente nei dati sul conto corrente sudcoreano, nei dati sul commercio delle Filippine e nei dati sulla fiducia delle imprese australiane.</p>
<p>Lunedì, i dati revisati del PIL del Giappone hanno rafforzato la fiducia del mercato nell’economia giapponese e aumentato le aspettative che la Banca del Giappone procederà con la normalizzazione della politica nella riunione di politica più avanti nella settimana. Il rendimento del bond governativo giapponese decennale è salito di 4,5 punti base lunedì, il più grande aumento in due mesi e sufficiente a invertire la metà del calo della settimana scorsa.</p>
<p>I massimi di chiusura record a Wall Street e i forti rendimenti del Tesoro degli Stati Uniti dovrebbero continuare a sostenere il dollaro statunitense, ma questa combinazione potrebbe mettere più pressione sugli asset dei mercati emergenti.</p>
<p>Venerdì, l’indice delle blue-chip CSI 300 e l’indice composito di Shanghai sono scesi ai minimi degli ultimi sei settimane. Con le borse cinesi chiuse lunedì, l’apertura di martedì potrebbe vedere una forte volatilità mentre gli investitori si riprendono sui guadagni delle due giornate di trading globale.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono aumentati martedì, prolungando i guadagni della giornata precedente in previsione di una maggiore domanda stagionale di carburante e della possibilità di acquisti di petrolio statunitensi per rimpinguare le sue riserve di petrolio. I guadagni sono stati limitati da un dollaro più forte. I futures del Brent sono saliti di 28 centesimi a $81,91 al barile, mentre i futures del West Texas Intermediate degli Stati Uniti sono saliti di 31 centesimi a $78,05 al barile.</p>
<p>I prezzi del petrolio sono saliti di circa il 3 percento a un massimo di una settimana lunedì, trainati dalle aspettative di una maggiore domanda di carburante quest’estate, nonostante un dollaro più forte in previsione che la Federal Reserve manterrà i tassi di interesse più alti.</p>
<p>L’oro era appena sopra i minimi di un mese a $2.306 all’oncia.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Sherry S. &amp; Icing. </strong>, Ricercatore di Gate.io<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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>