Tm90aXppZSBxdW90aWRpYW5lIHwgUHJvYmxlbWkgZGVsbGEgcmV0ZSBCbGFzdCByaXNvbHRpLCBnbGkgYWdnaW9ybmFtZW50aSBkaSBEZW5jdW4gaGFubm8gcmlkb3R0byBpIGNvc3RpIGRpIHF1YXNpIGlsIDkwJTsgRm9uZGF0b3JlIGRpIEJpdGNvaW4gRm9nIGNvbmRhbm5hdG8gcGVyIGFjY3VzZSBkaSByaWNpY2xhZ2dpbyBkaSBkZW5

2024-03-14, 04:14

<p><img src="https://gimg2.gateimg.com/image/article/17103895881_9.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20rete20Blast20ha20recuperato20blocchi20e20risolto20problemi20di20integrazione20laggiornamento20di20Dencun20riduce20i20costi20di20ZkSync20Era20dell8820Il20fondatore20di20Bitcoin20Fog20condannato20a205020anni20di20prigione20per20reati20di20riciclaggio20di20denaro87529"><a name="Crypto Daily Digest: La rete Blast ha recuperato blocchi e risolto problemi di integrazione; l’aggiornamento di Dencun riduce i costi di ZkSync Era dell’88%; Il fondatore di Bitcoin Fog condannato a 50 anni di prigione per reati di riciclaggio di denaro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La rete Blast ha recuperato blocchi e risolto problemi di integrazione; l’aggiornamento di Dencun riduce i costi di ZkSync Era dell’88%; Il fondatore di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Fog condannato a 50 anni di prigione per reati di riciclaggio di denaro</h2><p>Riguardo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Secondo i dati di Farside Investor, le attività di trading ETF indicano che l’uscita di Grayscale GBTC è stata di circa $276,5 milioni il 13 marzo, l’afflusso di Bitwise Bitcoin Spot ETF (BITB) è stato di $5,6 milioni, l’afflusso di ARK 21Shares Bitcoin Spot ETF (ARKB) è stato di $44,6 milioni e l’afflusso di Fidelity Bitcoin Spot ETF (FBTC) è stato di $281,5 milioni.</p>
<p>Dopo il lancio del mainnet Blast, problemi con i punti e il tempo di bridging hanno causato insoddisfazione nella comunità. Oggi, il post ufficiale di Blast sulla piattaforma X ha dichiarato che la sospensione della produzione di blocchi della scorsa notte è stata risolta, la rete ha ripreso la produzione di blocchi e un rapporto di analisi del problema sarà rilasciato il prima possibile.</p>
<p>Pacman ha anche fatto progressi nella risoluzione e nell’aggiornamento dei problemi precedenti correlati, inclusi:</p>
<ol>
<li><p>La riduzione dei punti dopo la migrazione del mainnet di Blast;</p>
</li><li><p>Anche se c’è un saldo nella mainnet, gli utenti vedono zero punti all’ora;</p>
</li><li><p>Nessun punto è stato ottenuto, ma i numeri vengono visualizzati;</p>
</li></ol>
<p>Un prompt che indica che il bonus non può essere ottenuto tempestivamente, anche se l’importo dei fondi sulla mainnet è lo stesso di prima.</p>
<p>In futuro, la rete potrebbe anche organizzare queste riparazioni, tra cui:</p>
<ol>
<li><p>Le ricompense durante il processo di conversione della rete principale sono inferiori a 10 volte;</p>
</li><li><p>I punti ottenuti dopo aver depositato in USDB sono inferiori alle aspettative (ci si aspetta che vengano corretti questa settimana);</p>
</li><li><p>Molte dApp hanno iniziato ad integrarsi con l’API dei punti e hanno modificato la classifica delle dApp per mostrare i punteggi di tutte le dApp, anziché solo i punteggi evidenziati (previsto un ottimizzazione nei prossimi 10 giorni).</p>
</li></ol>
<p>L’aggiornamento di Dencun è in atto e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ha ufficialmente attivato l’aggiornamento Dencun hard fork a Beacon height 8,626,176. Dopo gli aggiornamenti della versione di rete L2 che supportano EIP-4844, si utilizza “blob” al posto di “calldata”. ZkSync Era è il primo L2 a utilizzare Blob, e Starknet lo supporta.</p>
<p>Il ricercatore L2BEAT donnoh.eth ha rivelato che prima di utilizzare Blob, il costo del sequencer zkSync Era è diminuito a circa 0.013 ETH dopo aver utilizzato Blob. Il costo dell’utilizzo di Calldata era di circa 0.115 ETH, una diminuzione di circa l’88%.</p>
<p>Secondo il rapporto di Cointelgraph, Roman Sterlingov, fondatore di Bitcoin Fog, un servizio di criptovaluta ibrido, è stato condannato negli Stati Uniti per riciclaggio di denaro, collusione nel riciclaggio di denaro, esercizio di un’attività di trasmissione di valuta non autorizzata e violazione della legge sulla trasmissione di valuta di Washington D.C. La pena massima per queste accuse è di 50 anni di reclusione, e la sentenza è prevista per il 15 luglio. L’avvocato di Stringoff, Tok Ekeland, ha dichiarato in un post che il suo team presenterà appello.</p>
<p>In base alle prove presenti negli indizi, Sterlingoff ha gestito Bitcoin Fog tra ottobre 2011 e aprile 2021, il che, secondo il Dipartimento di Giustizia degli Stati Uniti (DOJ), è un servizio di riciclaggio di denaro fornito a ‘criminali che cercano di nascondere guadagni illegali dalle agenzie di controllo’.</p>
<p>Il servizio ha trasferito oltre 1,2 milioni di Bitcoin, e la giuria ha deciso di confiscare gli asset del Bitcoin Fog Fund sequestrato, compresi 1.354 Bitcoin detenuti nel Bitcoin Fog Wallet e quasi $350.000 in varie criptovalute detenute nel conto Kraken sequestrato.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20sta20scambiando20orizzontalmente20ad20un20livello20elevato20e20la20stagione20degli20Altcoin2020iniziata161020"><a name="Tendenze di mercato: BTC sta scambiando orizzontalmente ad un livello elevato e la stagione degli Altcoin è iniziata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC sta scambiando orizzontalmente ad un livello elevato e la stagione degli Altcoin è iniziata</h2><p>BTC sta ancora mantenendo un livello relativamente alto di stabilità, che è un segnale positivo per l’intero mercato delle criptovalute poiché gli Altcoin stanno iniziando a mostrare una tendenza al rialzo collettiva. Dopo l’aggiornamento di Cancun di ieri sera, le prestazioni dell’ecosistema di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sono state deludenti, mentre STRK è stato il primo a registrare un calo. Questa situazione dimostra la differenziazione interna e la volatilità del mercato delle criptovalute.</p>
<p>Per quanto riguarda la macroeconomia, il mercato azionario statunitense oscilla con guadagni deboli, che potrebbero influire sul sentiment degli investimenti nel mercato delle criptovalute. La crescente correlazione tra le criptovalute e i mercati finanziari tradizionali li rende più sensibili ai fattori macroeconomici.</p>
<h3 id="h3-Hotspot20di20mercato522409"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><ol>
<li><p>L’ecosistema SOL sta vivendo una crescita rapida: il token SOL nel <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema ha vissuto un’impennata e progetti come MOBILE, JUP, RAY, WIF e MYRO hanno registrato un’impennata collettiva. Dopo l’aggiornamento di Cancun, il mercato ha esaltato l’ecosistema SOL, provocando una inversione del tasso di cambio SOL/BTC.</p>
</li><li><p>AEVO lanciato: Il lancio di AEVO ha attirato ampia attenzione di mercato e il suo valore di mercato ha superato il progetto leader, DYDX, nel mercato dei derivati centralizzati. Tuttavia, ciò ha anche scatenato un diffuso sentimento di vendita allo scoperto nel mercato, con i contratti AEVO che mantengono tassi negativi, che potrebbero essere una reazione di mercato incerta al loro futuro sviluppo.</p>
</li></ol>
<p>Nel complesso, il mercato delle criptovalute continua a fluttuare sotto l’influenza di vari fattori. Gli investitori devono monitorare attentamente le tendenze di mercato e regolare tempestivamente le loro strategie di investimento per adattarsi ai cambiamenti di mercato. Nel frattempo, la gestione del rischio e la diversificazione degli asset sono anche fattori a cui gli investitori dovrebbero prestare attenzione per far fronte alla potenziale volatilità e ai rischi che il mercato potrebbe comportare.</p>
<h2 id="h2-Macro20SampP20e20Nasdaq20leggermente20pi20bassi20consolidamento20del20mercato20globale20petrolio20greggio20e20oro20rimangono20stabili97530"><a name="Macro: S&amp;P e Nasdaq leggermente più bassi, consolidamento del mercato globale, petrolio greggio e oro rimangono stabili" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: S&amp;P e Nasdaq leggermente più bassi, consolidamento del mercato globale, petrolio greggio e oro rimangono stabili</h2><p>Reuters ha riportato che il 13 marzo i mercati azionari globali sono stati principalmente in fase di consolidamento e a stretta volatilità, con l’indice S&amp;P 500 e l’indice NASDAQ in lieve calo mercoledì, poiché gli investitori hanno preso profitto dalle azioni dei produttori di chip e hanno atteso ulteriori segnali sui dati dei prezzi di produzione e sulle tendenze dell’inflazione prima dell’incontro della Federal Reserve della prossima settimana. L’indice dei semiconduttori (.SOX) è diminuito del 2,5% dopo la sua recente forte crescita, e è aumentato del 17% finora quest’anno. Le azioni di NVDA.O, trainate da un sentimento ottimista verso l’intelligenza artificiale, hanno recentemente registrato una crescita in questo settore, ma le azioni sono diminuite dell’1,1%.</p>
<p>I dati sui prezzi al consumo leggermente superiori alle attese di martedì non sono riusciti a scemare le speranze di tagli dei tassi di interesse nei prossimi mesi, e giovedì saranno resi noti anche i dati sulle vendite al dettaglio mensili degli Stati Uniti.</p>
<p>I dati sui prezzi alla produzione negli Stati Uniti di febbraio rilasciati giovedì potrebbero fornire ulteriori dettagli sull’inflazione. Quincy Krosby, stratega globale capo presso LPL Financial, ha dichiarato: “I dati più recenti aiutano effettivamente a sottolineare la tendenza all’intensificarsi dell’inflazione. Pertanto, questo sarà importante.”</p>
<p>Il mercato asiatico giovedì non ha avuto una direzione chiara, anche se è rimasto vicino a un massimo di sette mesi. Mentre gli investitori attendevano nuovi catalizzatori per chiarire ulteriormente il ciclo di allentamento dei tassi di interesse globali, hanno principalmente scambiato lateralmente. Gli investitori si stanno preparando per una potenziale riunione della politica della Banca del Giappone la prossima settimana, che potrebbe essere volatile.</p>
<p>Secondo lo strumento CME FedWatch, sebbene ci si aspetti ampiamente che la Federal Reserve mantenga invariati i tassi di interesse alla riunione della prossima settimana, i trader prevedono una probabilità del 65% del primo taglio dei tassi a giugno.</p>
<p>L’evento principale del calendario economico asiatico di giovedì è stato il rilascio dei dati sull’inflazione dei prezzi all’ingrosso in India. Il giorno precedente, i dati hanno mostrato che, sebbene la produzione industriale non abbia soddisfatto le aspettative, l’inflazione annuale dei consumatori a febbraio è stata leggermente superiore alle previsioni.</p>
<p>In Cina, l’indice blue chip Shanghai e Shenzhen 300 (.CSI300) è salito dello 0,46%, mentre l’indice composito di Shanghai (.SSEC) è salito leggermente dello 0,25%; L’indice di Hong Kong Hang Seng (.HSI) ha aperto una nuova scheda, trascinato dal calo dello 0,9% delle azioni tecnologiche, scendendo dello 0,1% (.HSTECH).</p>
<p>Per quanto riguarda le materie prime, il petrolio Brent è salito di 8 centesimi a $84,11 al barile, mentre il petrolio statunitense è salito di 7 centesimi a $79,79 al barile.</p>
<p>L’oro spot è rimasto stabile a $2,174.69 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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 suggerimenti 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, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>