Tm90aXppZSBxdW90aWRpYW5lIHwgQ3VydmUgRmluYW5jZSDDqCBzdGF0byBoYWNrZXJhdG8gZSBoYSBwZXJzbyBvbHRyZSA1MiBtaWxpb25pIGRpIGRvbGxhcmk7IElsIHZvbHVtZSBtZW5zaWxlIGRlZ2xpIHNjYW1iaSBkaSBmdXR1cmUgQ01FIEJUQyBoYSByYWdnaXVudG8gdW4gbWFzc2ltbyBhbm51YWxlOyBNaWNoYWVsIFNheWxvciB

2023-07-31, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/16907837350731.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Curve20Finance2020stato20hackerato20Il20volume20mensile20di20scambi20dei20futures20su20Bitcoin20del20CME20ha20raggiunto20un20massimo20annuale20Michael20Saylor20ha20affermato20che20la20quota20di20mercato20di20BTC20salir20all80959893"><a name="Crypto Daily Digest: Curve Finance è stato hackerato; Il volume mensile di scambi dei futures su Bitcoin del CME ha raggiunto un massimo annuale; Michael Saylor ha affermato che la quota di mercato di BTC salirà all’80%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Curve Finance è stato hackerato; Il volume mensile di scambi dei futures su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> del CME ha raggiunto un massimo annuale; Michael Saylor ha affermato che la quota di mercato di BTC salirà all’80%</h2><p>Nella prima mattina del 31 luglio, l’account Twitter ufficiale di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’compiler EVM Vyper ha twittato che le versioni di Vyper 0.2.15, 0.2.16 e 0.3.0 sono vulnerabili a fallimenti di blocco ricorsivo. L’indagine è in corso, ma qualsiasi progetto che si basi su queste versioni dovrebbe contattare immediatamente il team. Successivamente, molti protocolli correlati hanno twittato per annunciare eventi di hacking influenzati da problemi correlati, con Curve Finance che è particolarmente vulnerabile all’exploit della vulnerabilità.</p>
<p>Secondo un tweet di Curve Finance, molti pool di stablecoin (alETH/msETH/PATH) che utilizzano Vyper 0.2.15 sono stati hackerati a causa del fallimento dei blocchi ricorsivi. Il team sta valutando la situazione e aggiornerà la comunità man mano che la situazione si sviluppa. I futures di CrvUSD e altri pool di fondi non sono interessati.</p>
<p>In precedenza, il linguaggio di programmazione <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Vyper ha annunciato che le chiusure ricorsive delle versioni Vyper 0.2.15, 0.2.16 e 0.3.0 erano invalide, attualmente sotto indagine.</p>
<p>Impattato dall’hack, il prezzo di <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a> Il token nativo di CRV è sceso a $0,59 in un certo punto ed è attualmente a $0,64, una diminuzione di circa il 13% in 24 ore.</p>
<p>Di conseguenza, la vulnerabilità di Vyper minaccia direttamente il DeFi dell’intero ecosistema Ethereum. Se tutti i progetti hanno aggiornato queste versioni, sarebbe un enorme disastro per il DeFi.</p>
<p>Il 30 luglio 2015 è stato ufficialmente lanciato il mainnet di Ethereum e generato un blocco Genesis. Il primo blocco contiene 8.893 transazioni, offrendo ricompense di blocco di 5ETH. Attualmente, la rete principale di Ethereum è in funzione da 8 anni.</p>
<p>Secondo i dati on-chain, attualmente, il numero totale di transazioni di Ethereum ha superato i 2,05 miliardi di Txns, il numero totale di indirizzi ha raggiunto i 296 milioni, il numero di indirizzi dei futures ha raggiunto i 61,61 milioni e il volume totale di trading ha raggiunto i 9,93 miliardi di ETH.</p>
<p>Anche se il volume degli scambi di criptovalute e degli scambi è diminuito, il CME Group ha stabilito il volume di scambi mensile più alto di quest’anno a luglio.</p>
<p>Il volume di trading del mercato dei futures di Bitcoin presso il Chicago Mercantile Exchange (CME) ha raggiunto il suo livello più alto ad aprile, con solo un giorno di negoziazione rimasto a luglio, raggiungendo un volume di trading di 53,33 miliardi di dollari. Ad aprile, il volume di trading dei futures della società ha raggiunto i 53,06 miliardi di dollari.</p>
<p>Al 29 luglio, le posizioni aperte nel mercato dei future Bitcoin del CME erano di $2.5 miliardi, indicando che il mercato è molto popolare tra gli investitori istituzionali come fondi speculativi e grandi società di trading.</p>
<p>Recentemente, Michael Saylor, ex CEO di MicroStrategy, ha commentato in un’intervista che la SEC sta attualmente citando in giudizio piattaforme come Coinbase e Binance, che secondo lui potrebbero portare opportunità di sviluppo senza precedenti per Bitcoin. Attualmente, la quota di mercato di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nelle criptovalute è compresa tra il 40% e il 48%. Michael Saylor prevede che la quota di mercato del bitcoin salirà a un sorprendente 80% in futuro e le restanti altcoin rappresenteranno solo il restante 20%.</p>
<p>Michael Saylor ritiene che poiché un gran numero di piattaforme di trading di criptovalute ha paura della SEC e delisterà le altcoin che potrebbero essere considerate titoli, Bitcoin diventerà la potenza ultima delle criptovalute.</p>
<p>Lo slancio di sviluppo del <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> a Hong Kong è in piena espansione. Dalla pubblicazione della “Dichiarazione politica sullo sviluppo degli asset virtuali a Hong Kong” nell’ottobre dello scorso anno, 90 imprese continentali ed estere legate agli asset virtuali hanno espresso interesse a stabilirsi a Hong Kong. A metà di quest’anno, il governo di Hong Kong ha istituito un sistema di licenze completo per i fornitori di servizi di asset virtuali, che contribuisce a garantire lo sviluppo stabile e ordinato del mercato e a salvaguardare gli interessi degli investitori.</p>
<p>A livello normativo, sono state frequenti azioni.</p>
<p>Di recente, il Presidente del Perù ha emesso un nuovo decreto che stabilisce che tutti gli scambi di criptovalute operanti nel paese devono conformarsi alle normative anti-riciclaggio (AML). Secondo la legge, i fornitori di servizi di asset virtuali, inclusi individui e aziende operanti all’interno del Perù, devono ora segnalare informazioni all’Unità di Intelligence Finanziaria (UIF-Perù). Questo dipartimento è responsabile di ricevere, analizzare e inviare informazioni per identificare attività di riciclaggio di denaro e finanziamento del terrorismo.</p>
<p>Nonostante la legge sia ora in vigore, è previsto che UIF-Peru rilasci nelle prossime giornate linee guida più specifiche per chiarire ulteriormente gli obblighi e le responsabilità dei fornitori di servizi di attività di beni virtuali nel paese.</p>
<p>I deputati del Congresso degli Stati Uniti Gus Bilirakis (repubblicano del Partito repubblicano della Florida) e Jan Schakowsky (democratico dell’Illinois) hanno inviato una lettera a Tim Cook, CEO di Apple, chiedendo se la Guida dell’App Store di Apple abbia ucciso tecnologie emergenti, come la tecnologia del registro distribuito e quella degli NFT.</p>
<p>Secondo l’Hindustan Times, la Corte Suprema dell’India ha istruito il governo federale a dichiarare se intende istituire un’agenzia federale per investigare sui casi criminali legati alle criptovalute, e ha affermato che è “sfortunato” che l’India non abbia ancora leggi o istituzioni per regolare le criptovalute fino ad ora.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi502909"><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-BTC447181"><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/1690783776BTC.png" alt=""><br>Nella settimana scorsa, BTC si è aggrappato continuamente al livello di supporto a $29.500 USD e la strategia rialzista sta aspettando una rottura a $30.888 USD per avviare posizioni long, con l’obiettivo massimo fissato a $36.000 USD. Lo scenario ribassista potrebbe testare il trend al rialzo ritracciandosi verso il supporto a $28.500 USD.</p>
<h3 id="h3-ETH337459"><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/1690783795ETH.png" alt=""><br>Nella scorsa settimana, ETH ha mantenuto il supporto a $1.857 USD e intende rimanere all’interno del trend al rialzo. Nel breve termine, attenzione dovrebbe essere posta ai possibili pullback verso la linea di tendenza. Un approccio rialzista conservativo sarebbe quello di attendere una rottura a $2.037 USD per entrare in posizioni con un obiettivo di profitto a $2.358 USD, utilizzando una strategia basata sul rapporto rischio-rendimento.</p>
<h3 id="h3-WLD757774"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1690783813WLD.png" alt=""><br>A breve termine, c’è la possibilità che si formi un chiaro pattern triangolare ascendente. Un approccio rialzista conservativo suggerisce di attendere una rottura a $2.55 USD per entrare in posizioni, con i seguenti obiettivi: $2.785 USD, $3.35 USD e un obiettivo massimo di $4.3 USD.</p>
<h2 id="h2-Macro20La20Federal20Reserve2020ottimista20sulleconomia20futura20concentrandosi20sui20dati20non20agricoli20di20venerd6934"><a name="Macro: La Federal Reserve è ottimista sull’economia futura, concentrandosi sui dati non agricoli di venerdì." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La Federal Reserve è ottimista sull’economia futura, concentrandosi sui dati non agricoli di venerdì.</h2><p>Secondo i dati pubblicati venerdì, l’indice dei prezzi PCE core negli Stati Uniti ha registrato un tasso annuale del 4,10% a giugno, inferiore al previsto 4,20% e 4,6%, l’aumento più basso da settembre 2021; Il tasso mensile ha registrato lo 0,2%, in linea con le aspettative e l’aumento più basso da novembre 2022.</p>
<p>Nel frattempo, l’indice dei costi del lavoro negli Stati Uniti ha registrato un tasso trimestrale dell’1% nel secondo trimestre, inferiore all’atteso 1,10% e all’1,2% del valore precedente.</p>
<p>Riflettendo il graduale raffreddamento del mercato del lavoro degli Stati Uniti. Sebbene la frequenza di pubblicazione dell’ECI differisca dagli indicatori di reddito nei rapporti sull’occupazione non agricola, gli economisti spesso lo preferiscono perché non cambierà a causa dei cambiamenti nella composizione occupazionale di diverse professioni o settori.</p>
<p>L’analisi istituzionale indica che il rapporto PCE ha dato buoni risultati, con un tasso di inflazione diminuito che ha superato le aspettative di mercato. L’indice complessivo dei prezzi PCE negli Stati Uniti è anche sceso al tasso annuale del 3,0% a giugno, il che non dovrebbe causare problemi al mercato.</p>
<p>La disinflazione e la crescita moderata della spesa dei consumatori hanno aumentato le possibilità per l’economia di raggiungere l’atterraggio morbido previsto dai responsabili delle politiche. I dati di giovedì e venerdì hanno mostrato che i dati economici degli Stati Uniti per la prima metà del 2023 hanno superato di gran lunga le aspettative di mercato, il che potrebbe rendere la Federal Reserve più ottimista sull’economia e lasciare spazio a ulteriori politiche di restrizione.</p>
<p>Previsioni importanti degli eventi per questa settimana:</p>
<p>Martedì 1 agosto, alle 11:34 (UTC), la sidechain di Ethereum <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a> Chain avvierà l’aggiornamento del mainnet Shapella al Slot 10379264 (epoca 648704);</p>
<p>Mercoledì 2 agosto, Cosmos Eco EVM Compatibility Chain <a href="/price/evmos-evmos" rel="nofollow noopener noreferrer" target="_blank">Evmos</a> Lancerà <a href="/price/evmos-evmos" target="_blank" class="blog_inner_link">Evmos</a> 2.0</p>
<p>Giovedì 3 agosto alle 09:40 (UTC), <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> si prevede di dimezzare. La ricompensa per blocco sarà ridotta da 12.5 LTC a 6.25 LTC.</p>
<p>Attualmente, l’attività ‘Chi è l’imperatore delle profezie di Gate.io: indovina il prezzo di LTC per condividere $25,000 di premi LTC’ è in corso. Accogliamo tutti a partecipare attivamente. Indovina ora!</p>
<p>Venerdì 4 agosto alle 12:30 (UTC): gli Stati Uniti pubblicheranno i dati relativi a luglio sul settore non agricolo, e il mercato prevede che il tasso di disoccupazione registrerà il 3,6%, con un aumento di 225.000 posti di lavoro.</p>
<p>Sabato 5 agosto, alle 00:00 (UTC), Tornado Cash (TORN) sbloccherà oltre 175.000 TORN, pari al 1,75% dell’emissione totale.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>