Tm90aXppZSBxdW90aWRpYW5lIHwgRWlnZW5MYXllciBoYSBudW92YW1lbnRlIGF1bWVudGF0byBpbCBsaW1pdGUgc3VwZXJpb3JlIGRlbCByZXN0YWtpbmcgZGkgTFNULCBpbCBwcm90b2NvbGxvIFp1bmFtaSDDqCBzdGF0byBoYWNrZXJhdG8sIGlsIHByZXp6byBkaSBVWkQgw6ggY3JvbGxhdG8=

2023-08-15, 03:08

<p><img src="https://gimg2.gateimg.com/image/article/16920724050815.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Zunami20Protocol2020stato20hackerato20UZD2020precipitato20e20la20capitalizzazione20di20mercato20di20DAI20aumenta20dopo20laumento20dei20tassi20di20interesse20di20MakerDAO784220"><a name="Crypto Daily Digest: Zunami Protocol è stato hackerato, UZD è precipitato e la capitalizzazione di mercato di DAI aumenta dopo l’aumento dei tassi di interesse di MakerDAO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Zunami Protocol è stato hackerato, UZD è precipitato e la capitalizzazione di mercato di DAI aumenta dopo l’aumento dei tassi di interesse di MakerDAO</h2><p>Per quanto riguarda le recenti tendenze del progetto, EigenLayer aumenterà il limite di restaking di LST il 22 agosto, consentendo agli utenti di depositare qualsiasi token da stETH, rETH e cbETH in EigenLayer. Quando qualsiasi LST staked raggiunge 100.000 token, EigenLayer sospende nuovamente l’accettazione dello staking.</p>
<p>In termini di dati di mercato, secondo i dati di L2BEAT, il volume totale bloccato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2 al momento è di $10.568 miliardi, in calo dello 0.43% negli ultimi 7 giorni. Tra questi, Arbitrum One e <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> hanno il volume più alto bloccato, rappresentando rispettivamente il 56,28% e il 26,74%, mostrando uno stato di distribuzione relativamente centralizzato.</p>
<p>D’altra parte, la dimensione di mercato di SparkProtocol, un protocollo di prestito sotto MakerDAO, si è avvicinata a 650 milioni di dollari e il volume totale dei prestiti di DAI ha raggiunto circa 200 milioni di dollari.</p>
<p>In termini di emissione e sblocco, dopo che MakerDAO ha aumentato i tassi di interesse, il valore di mercato di DAI è aumentato di quasi 1 miliardo di dollari negli ultimi 7 giorni. Questa misura incentivante ha anche influenzato il numero di stablecoin decentralizzate nei contratti DSR, passando da un record di 339,4 milioni il 6 agosto a 1,27 miliardi.</p>
<p>Il numero di token SAND che hanno iniziato a sbloccarsi ieri è ora entrato nell’exchange con oltre 81 milioni di token. Oggi, rimarranno sbloccati 332 milioni di token SAND, pari al 16% dell’offerta attuale in circolazione.</p>
<p>In altre notizie, Chainlink ha aggiunto 7 nuove integrazioni di servizi 12 sulla catena, appartenenti a 3 diversi Chainlinks. Questo aggiornamento senza dubbio migliora notevolmente la copertura e la compatibilità di Chainlink stesso.</p>
<p>Ieri, il protocollo di aggregazione dei ricavi Zunami Protocol ha twittato che zStaples era stato hackerato, ma il collaterale è rimasto sicuro. Questo hack ha causato perdite di oltre $2,1 milioni, e i fondi rubati sono affluiti in Tornado Cash. La stablecoin UZD del protocollo Zunami è scesa del 96,8% in un breve periodo di tempo.</p>
<p>Curve è stata influenzata da hacking precedenti e la sua piattaforma di liquidità dell’ecosistema, Conic Finance, sta attualmente subendo un’approfondita revisione da parte di MixBytes e ChainSecurity.</p>
<p>La pagina di governance di Yearn Finance mostra che Wintermute ha presentato proposte per il prestito YFI Wintermute e il piano CRV, chiedendo l’approvazione per fornire prestiti YFI a Wintermute Trading e autorizzando il trasferimento di 350 YFI dal tesoro DAO per un periodo di 12 mesi, con un tasso di interesse dello 0,1%.</p>
<p>La notizia piuttosto comica di oggi è che Zuckerberg ha affermato che Musk ha rifiutato di confermare la data del duello tra i due in precedenza, e Musk ha risposto via messaggio di testo che busserebbe alla porta di Zuckerberg domani. Man mano che questo evento si riscalda gradualmente, le piattaforme X e Meta potrebbero attirare un’ondata di attenzione, e corrispondente <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> potrebbe inaugurare nuovi punti caldi di crescita.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi789185"><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-BTC175879"><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/1692072439BTC.png" alt=""><br>Nel corso degli ultimi sei mesi, la sua volatilità ha raggiunto un nuovo minimo. Si prevede che mostri un modello convergente nella mattinata del 22. Un approccio rialzista conservativo suggerisce di entrare in posizioni long su una rottura sopra i 30.888 dollari statunitensi o di avviare posizioni corte al di sotto dei 28.535 dollari statunitensi. La struttura complessiva deve mantenere la stabilità sopra la linea di tendenza crescente viola.</p>
<h3 id="h3-TRB166132"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1692072455TRB.png" alt=""><br>Il grafico giornaliero mostra un grande modello di testa e spalle rialzista, e la consolidazione a un livello basso è persistita per quasi quattro mesi. Posizioni a breve termine possono essere avviate sopra i $12,65 dollari statunitensi. Gli obiettivi da tenere d’occhio includono $14,35 dollari statunitensi, $17,24 dollari statunitensi e $22,55 dollari statunitensi in sequenza. È consigliabile utilizzare una strategia rischio-rendimento per avviare posizioni a livelli più bassi.</p>
<h3 id="h3-BAKE461141"><a name="BAKE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BAKE</h3><p><img src="https://gimg2.gateimg.com/image/article/1692072470BAKE.png" alt=""><br>Il mercato a breve termine ha mostrato un’attività significativa. Il prezzo di entrata raccomandato ieri era di 0,1050 dollari USA, con un obiettivo di 0,1415 dollari USA. Questa mattina, il prezzo più alto riportato è stato di 0,1421 dollari USA, con un picco di aumento del 33,75%. Se il trend rialzista continua, potrebbe raggiungere $ 0,1567 dollari USA e $ 0,1697 dollari USA.</p>
<h2 id="h2-Macro20La20visione20della20Federal20Reserve20di20sospendere20gli20aumenti20dei20tassi20di20interesse2020aumentata20e20il20mercato20esterno20sta20tendendo20a20calmarsi202287"><a name="Macro: La visione della Federal Reserve di sospendere gli aumenti dei tassi di interesse è aumentata, e il mercato esterno sta tendendo a calmarsi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La visione della Federal Reserve di sospendere gli aumenti dei tassi di interesse è aumentata, e il mercato esterno sta tendendo a calmarsi</h2><p>Goldman Sachs ha previsto nel suo rapporto di ricerca pubblicato la mattina presto del 14 che il FOMC inizierà ad abbassare il tasso dei fondi federali nel secondo trimestre del 2024, con un taglio trimestrale previsto dei tassi di 25 punti base. Se questa previsione è accurata, il FOMC può abbassare i tassi più velocemente.</p>
<p>Riguardo a questa previsione, l’ex presidente della Federal Reserve di Dallas, Kaplan, condivide lo stesso punto di vista. Si aspetta che il FOMC decida di sospendere gli aumenti dei tassi di interesse al prossimo incontro a settembre.</p>
<p>Attualmente, Yellen dagli Stati Uniti ha dichiarato che l’attuale tasso di inflazione negli Stati Uniti sta diminuendo e il mercato del lavoro sta mostrando uno stato forte. Sebbene vi sia ancora un rischio di recessione, è necessario prestare maggiore attenzione all’influenza dei paesi esterni.</p>
<p>Lo stesso giorno, c’è stata una correzione su larga scala del mercato azionario statunitense, che ha reso il sentiment del mercato ancora più incerto. Allo stesso tempo, il tasso di cambio tra il dollaro USA e le varie valute è continuato allo stato precedente.</p>
<p>L’impatto macroeconomico attuale sul mercato delle criptovalute si sta stabilizzando temporaneamente, mentre i prezzi delle criptovalute mainstream come BTC e ETH sono in calo. Potrebbe esserci un trend al rialzo nel mercato nel breve termine.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</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 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></div>