SWwgdGVzb3JvIGRhIDE2OCBtaWxpb25pIGRpIGRvbGxhcmkgZGVsIGZvbmRhdG9yZSBkaSBDdXJ2ZSDDqCBzb3R0byBzdHJlc3M=

2023-08-17, 07:44

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR247387"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>I $168 milioni di criptovalute di Egorov su Curve Finance erano a rischio di liquidazione dopo il recente hack.</p>
<p>Una massiccia liquidazione di CRV avrebbe avuto un impatto negativo sulla liquidità di diverse piattaforme DeFi, tra cui gate. <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>.</p>
<p>Gli audit di sicurezza dei protocolli DeFi e i sistemi di sicurezza robusti possono aiutare a evitare sfruttamenti maliziosi.</p>
<h2 id="h2-Introduzione279901"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molti platform decentralizzate come gli scambi e le piattaforme di trading sono ovvi obiettivi per hacker e truffatori. Lo sfruttamento malizioso di una piattaforma decentralizzata potrebbe seminare il panico tra gli investitori e l’intera industria blockchain. Inoltre, gli attacchi potrebbero influenzare altri progetti crittografici poiché il sistema blockchain connette vari protocolli.</p>
<p>Oggi discutiamo dell’effetto del recente hacking di <a href="https://www.gate.io/live/video/24c11c91ff7dcacec7feca541febe515" target="_blank">Curve Finance</a>. Esploreremo anche i pericoli che sorgono quando un individuo o un’azienda detiene una grande quantità di un’attività crittografica come CRV.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2637" target="_blank">Curve Finance crvUSD, espandendo la sua piattaforma DeFi Stablecoin</a></p>
<h2 id="h2-La20minaccia20di20hacking20di20Curve20Finance20minaccia20il20settore20della20finanza20decentralizzata20DeFi227687"><a name="La minaccia di hacking di Curve Finance minaccia il settore della finanza decentralizzata (DeFi)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La minaccia di hacking di Curve Finance minaccia il settore della finanza decentralizzata (DeFi)</h2><p>L’utilizzo malintenzionato di Curve Finance, uno scambio decentralizzato, ha minacciato una serie di settori di DeFi in quanto ne influisce sulla liquidità. Il 30 luglio alcuni attaccanti hanno <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">Curve Finance sfruttato</a> attraverso una vulnerabilità esistente sul compilatore Vyper.</p>
<p>Diverse pool che includono pETH/ETH di PEGD, msETH/ETH di Metronome e alETH/ETH di Alchemix sono stati sfruttati, risultando nel furto di oltre $60 milioni di asset crittografici. L’obiettivo degli hacker era accedere al token Curve Finance DAO (CRV), a diversi stablecoin e ad altri asset crittografici come ETH.</p>
<p>Oltre a perdere le varie criptovalute, l’ecosistema di Curve Finance è stato pesantemente colpito dal crollo del prezzo del suo token nativo (CRV) di circa il 20% a seguito dello sfruttamento.</p>
<p>È anche importante notare che Vyper è un linguaggio di programmazione utilizzato per scrivere smart contract su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Alcuni membri del team di sviluppo hanno affermato che la versione precedente di Vyper era vulnerabile allo sfruttamento. In questo caso, la vulnerabilità chiamata attacco di rientro ha permesso all’aggressore di prelevare continuamente asset crittografici senza che il protocollo si rendesse conto di averli già inviati.</p>
<h2 id="h2-Comprendere20Curve20Finance127099"><a name="Comprendere Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprendere Curve Finance</h2><p>Ora, per comprendere l’impatto dello sfruttamento, dobbiamo apprezzare il ruolo di Curve Finance in DeFi. Curve Finance, lanciato nel 2020, è uno scambio decentralizzato (DEX) che esiste sulla blockchain di Ethereum. Fondamentalmente, la piattaforma consente agli utenti di scambiare diverse criptovalute senza intermediari.</p>
<p>Individui ed entità possono investire in diversi pool attraverso un processo chiamato fornitura di liquidità. Ancora una volta, è uno strumento di arbitraggio importante per i trader per asset che si scollegano di valore l’uno dall’altro. In effetti, Curve Finance è uno dei più grandi scambi decentralizzati con più di <a href="https://defillama.com/protocol/curve-finance" rel="nofollow noopener noreferrer" target="_blank">$1.6 miliardi di valore totale bloccato</a> (TVL).</p>
<h2 id="h2-Il20magazzino20da2016820milioni20del20fondatore20di20Curve2020a20rischio970941"><a name="Il magazzino da $168 milioni del fondatore di Curve è a rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il magazzino da $168 milioni del fondatore di Curve è a rischio</h2><p>Mentre molti investitori sono stati colpiti dall’hack, i $168 milioni di token CRV di Michael Egorov (fondatore di Curve Finance) sono stati motivo di preoccupazione. Il calo del prezzo di CRV che è seguito all’hack ha minacciato la liquidità della criptovaluta Curve Finance. Ulteriori diminuzioni del valore del token CRV potrebbero portare alla liquidazione del token.</p>
<p>Il motivo è che Agorov aveva utilizzato CRV come garanzia per prestiti in vari protocolli di prestito. Infatti, ha utilizzato CRV del valore di 168 milioni di dollari, circa il 34% dell’offerta totale, per garantire diversi prestiti.</p>
<p>Ad esempio, Egorov ha utilizzato $63 milioni di CRV come garanzia per un prestito su Aave. Ha anche utilizzato $32 milioni di CRV come garanzia per ottenere la stablecoin <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> su Fraxlend, l’emittente di stablecoin. Ha anche avuto un prestito di $18 milioni su Abracadabra. Secondo DefiLlama, la garanzia di CRV di Egorov verrebbe liquidata quando il suo valore raggiunge $0.37.</p>
<p>Tuttavia, dopo lo sfruttamento di Curve Finance, Egorov ha adottato diverse misure per evitare una possibile stretta di liquidità che potrebbe far scendere il valore di CRV al di sotto di $0.37. Egorov ha rinforzato il capitale vendendo LIDO, il token nativo di Lido, una piattaforma di staking liquido. Ha anche ripagato alcuni dei suoi prestiti per ridurre l’impatto di una possibile liquidazione.</p>
<p>Inoltre, Curve Finance ha offerto una ricompensa del 10% per la restituzione delle criptovalute rubate. Secondo CoinDesk, <a href="https://www.coindesk.com/tech/2023/08/07/curve-recoups-73-of-hacked-funds-bolstering-crv-sentiment/" rel="nofollow noopener noreferrer" target="_blank">Curve Finance ha recuperato il 75%</a> dei beni crittografici rubati dopo aver offerto la taglia.</p>
<h2 id="h2-Potenziali20effetti20della20liquidazione20dei2016820milioni20di20Egorov85860"><a name="Potenziali effetti della liquidazione dei $168 milioni di Egorov" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potenziali effetti della liquidazione dei $168 milioni di Egorov</h2><p>Se il prezzo di CRV potesse scendere sotto i $0,37, ciò potrebbe portare alla liquidazione del collaterale del prestito di Egorov di CRV del valore di $168 milioni. L’effetto di tale liquidazione sarebbe molto ampio, poiché diverse piattaforme di prestito e Curve Finance si troverebbero ad affrontare sfide di liquidità.</p>
<p>Ad esempio, poco dopo l’hack il valore totale bloccato di Curve Finance è diminuito di circa il 44%, mentre il TVL per l’intero settore DeFi è diminuito di oltre 2 miliardi di dollari. Come osserviamo da questa evoluzione, la liquidazione dei 168 milioni di dollari di Egorov in Curve Finance potrebbe avere un effetto contagio sui protocolli DeFi in cui CRV è utilizzato come collaterale.</p>
<p>La liquidazione di CRV porterebbe ad una massiccia vendita ad un prezzo molto basso che potrebbe influire sulla liquidità di vari progetti cripto che ci hanno a che fare. Allo stesso modo, la liquidazione probabilmente spingerebbe ulteriormente il prezzo verso il basso, il che potrebbe creare panico tra gli investitori. Vale la pena notare che CRV è associato a varie criptovalute in diverse piattaforme di finanza decentralizzata come gate. <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> e <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>.</p>
<p>Inoltre, questo incidente di hacking ha mostrato che il possesso concentrato di un cripto-asset nelle mani di uno o pochi individui o entità può avere conseguenze disastrose. Se tali individui utilizzano grandi quantità di un token/coin specifico come collaterale o per il trading con leva, la sua liquidazione potrebbe portare a una brusca caduta del prezzo. Ciò potrebbe risultare in una vendita di massa e in un possibile collasso.</p>
<p>Inoltre, quando la comunità degli investitori si rende conto che un asset criptato è nelle mani di poche persone o entità che possono creare un sentimento negativo che potrebbe influenzarne negativamente il valore. Questo è il motivo per cui molti investitori al dettaglio monitorano le attività delle balene per determinare il potenziale movimento dei prezzi di specifiche criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/648/what-is-curve-war-gain-insight-into-curve-the-stablecoin-exchange-leader" target="_blank">Cosa è Curve War: Ottieni una panoramica su Curve - Il leader dello scambio di stablecoin</a></p>
<h2 id="h2-Misure20per20mitigare20i20rischi20legati20agli20investimenti20in20criptovalute575749"><a name="Misure per mitigare i rischi legati agli investimenti in criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misure per mitigare i rischi legati agli investimenti in criptovalute</h2><p>L’industria delle criptovalute ha anche tratto insegnamenti preziosi dall’hacking di Curve Finance e dalla potenziale liquidazione di CRV del valore di 168 milioni di dollari di Egorov.</p>
<p>Innanzitutto, le società DeFi dovrebbero effettuare una dovuta diligenza prima di offrire grandi prestiti a individui ed entità. Come evidenziato in questo caso, Egorov ha accumulato un terzo dell’offerta di CRV da utilizzare come garanzia per prestiti del valore di milioni di dollari, denominati in criptovalute, principalmente stablecoin.</p>
<p>La liquidazione delle criptovalute che fanno parte del collaterale influenzerebbe la liquidità e la redditività dell’intero settore DeFi. Pertanto, i protocolli di prestito dovrebbero salvaguardare il valore delle criptovalute limitando le posizioni di grandi dimensioni che possono creare rischi sistematici.</p>
<p>I progetti di criptovaluta dovrebbero creare sinergie e collaborazioni per proteggere i fondi degli investitori. Ad esempio, lo spirito collaborativo dimostrato dagli hacker white hat e dagli operatori di bot MEV è importante poiché hanno aiutato a recuperare parte delle criptovalute rubate.</p>
<p>Inoltre, il fatto che criptovalute per milioni di dollari siano state rubate a causa di una vulnerabilità nel linguaggio di programmazione Vyper indica la necessità di audit di sicurezza rigorosi e dell’implementazione di robusti sistemi e pratiche di sicurezza.</p>
<h2 id="h2-Conclusione889514"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Dopo l’hacking di Curve Finance, i $168 milioni di CRV di Egorov erano sotto minaccia di una possibile liquidazione massiccia. Il motivo di ciò è che Egorov ha utilizzato i token come garanzia per vari prestiti criptati. Una grande liquidazione avrebbe anche influenzato la liquidità di vari platform DeFi che hanno CRV come parte dei loro portafogli.</p>
<h2 id="h2-Domande20frequenti20su20Curve20Finance891059"><a name="Domande frequenti su Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Curve Finance</h2><h3 id="h3-Cos20Curve20Finance981902"><a name="Cos’è Curve Finance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Curve Finance?</h3><p>Curve Finance è uno scambio decentralizzato dove le persone possono scambiare criptovalute. Chiunque può depositare i propri asset crittografici in diverse pool che esistono sulla piattaforma.</p>
<h3 id="h3-Curve20Finance2020sicuro464958"><a name="Curve Finance è sicuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve Finance è sicuro?</h3><p>Curve Finance è sicuro poiché non ha subito molti attacchi malevoli nel corso degli anni. Tuttavia, come qualsiasi altro sistema decentralizzato, attori malevoli potrebbero comprometterlo in qualsiasi momento a seconda delle sue attuali pratiche di sicurezza.</p>
<h3 id="h3-Perch20comprare20CRV873746"><a name="Perché comprare CRV?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché comprare CRV?</h3><p>CRV è una governance <a href="https://www.gate.io/price/curve-dao-crv" target="_blank">token di Curve Finance</a>, uno dei principali exchange decentralizzati. Poiché c’è un’elevata domanda per i servizi di Curve Finance, è probabile che CRV mantenga un valore stabile nel tempo. Allo stesso modo, la piattaforma ha una tecnologia molto preziosa e molti trader la utilizzano. Leggi anche come <a href="https://www.gate.io/how-to-buy/curve-dao-crv" target="_blank">per acquistare Curve DAO</a></p>
<h3 id="h3-CRV2020un20buon20investimento250301"><a name="CRV è un buon investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CRV è un buon investimento?</h3><p>CRV è un buon investimento in quanto supporta uno scambio decentralizzato i cui prodotti e servizi sono molto richiesti. Molti investitori in criptovalute scambiano migliaia di criptovalute su Curve Finance.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista del ricercatore e non costituisce suggerimenti 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 sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>