RGUgJDE2OCBtaWxqb2VuIHZhbiBkZSBvcHJpY2h0ZXIgdmFuIEN1cnZlIHdvcmR0IGdlY29uZnJvbnRlZXJkIG1ldCBzdHJlc3M=

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR514646"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Egorov’s $168 miljoen aan Curve Finance crypto stond onder dreiging van een liquidatie na de recente hack.</p>
<p>Een enorme liquidatie van CRV zou een negatieve invloed hebben gehad op de liquiditeit van verschillende DeFi-platforms, waaronder gate. <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>.</p>
<p>Veiligheidsaudits van DeFi-protocollen en robuuste veiligheidsen kunnen helpen om kwaadwillige misbruik te voorkomen.</p>
<h2 id="h2-Introductie869930"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Veel gedecentraliseerde platforms zoals beurzen en handelsplatforms zijn voor de hand liggende doelwitten voor hackers en oplichters. Kwaadwillende exploitatie van een gedecentraliseerd platform kan paniek veroorzaken onder investeerders en de hele blockchain-industrie. Bovendien kunnen de exploits andere crypto-projecten beïnvloeden, aangezien het blockchain-systeem verschillende protocollen met elkaar verbindt.</p>
<p>Vandaag bespreken we het effect van de recente hacking van <a href="https://www.gate.io/live/video/24c11c91ff7dcacec7feca541febe515" target="_blank">Curve Finance</a>. We zullen ook de gevaren onderzoeken die ontstaan wanneer een individu of bedrijf een grote hoeveelheid van een crypto-activum zoals CRV bezit.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2637" target="_blank">Curve Finance crvUSD, breidt zijn DeFi Stablecoin Platform uit</a></p>
<h2 id="h2-Curve20Finance20Hacken20Bedreigt20de20Gedecentraliseerde20Financile20DeFi20Sector420841"><a name="Curve Finance Hacken Bedreigt de Gedecentraliseerde Financiële (DeFi) Sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve Finance Hacken Bedreigt de Gedecentraliseerde Financiële (DeFi) Sector</h2><p>De kwaadaardige exploitatie van Curve Finance, een gedecentraliseerde uitwisseling, bedreigde een dwarsdoorsnede van de DeFi-sector omdat het de liquiditeit ervan beïnvloedt. Op 30 juli vielen enkele aanvallers <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">uitgebuite Curve Finance</a> via een kwetsbaarheid die bestond in de Vyper-compiler.</p>
<p>Verschillende pools, waaronder PEGD’s pETH/ETH, Metronome’s msETH/ETH en Alchemix’s alETH/ETH, zijn uitgebuit, wat heeft geleid tot diefstal van meer dan $60 miljoen aan crypto-activa. Het doel van de hackers was om toegang te krijgen tot het Curve Finance DAO-token (CRV), verschillende stablecoins en andere crypto-activa zoals ETH.</p>
<p>Afgezien van het verlies van de verschillende cryptocurrencies werd het Curve Finance-ecosysteem zwaar getroffen doordat de prijs van zijn eigen token (CRV) met ongeveer 20% daalde in de nasleep van het misbruik.</p>
<p>Het is ook belangrijk om op te merken dat Vyper een programmeertaal is die wordt gebruikt voor het schrijven van slimme contracten op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Sommige leden van het ontwikkelingsteam zeiden dat de oudere versie van Vyper kwetsbaar was voor misbruik. In dit g maakte de kwetsbaarheid genaamd re-entrancy aanval het mogelijk voor de aanvaller om voortdurend crypto activa op te nemen zonder dat het protocol zich realiseerde dat het ze al had verzonden.</p>
<h2 id="h2-Begrip20van20Curve20Finance183069"><a name="Begrip van Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrip van Curve Finance</h2><p>Om de impact van de exploit te begrijpen, moeten we de rol van Curve Finance in DeFi waarderen. Curve Finance, gelanceerd in 2020, is een gedecentraliseerde beurs (DEX) die bestaat op de Ethereum-blockchain. Kortom, het platform stelt de gebruikers in staat om verschillende cryptocurrencies te ruilen zonder tussenpersonen.</p>
<p>Individuen en entiteiten kunnen investeren in verschillende pools via een proces dat liquiditeitsverschaffing wordt genoemd. Opnieuw is het een belangrijk arbitragemiddel voor handelaren voor activa die van elkaar verschillen in waarde. In feite is Curve Finance een van de grootste gedecentraliseerde beurzen met meer dan <a href="https://defillama.com/protocol/curve-finance" rel="nofollow noopener noreferrer" target="_blank">$1.6 miljard aan totale waarde vergrendeld</a> (TVL).</p>
<h2 id="h2-16820miljoen20van20Curveoprichter20loopt20risico186678"><a name="$168 miljoen van Curve-oprichter loopt risico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$168 miljoen van Curve-oprichter loopt risico</h2><p>Terwijl veel investeerders getroffen werden door de hack, is de $168 miljoen aan CRV-tokens van Michael Egorov (oprichter van Curve Finance) een bron van zorg geweest. De prijsdaling van CRV die volgde op de hack bedreigde de liquiditeit van de Curve Finance crypto. Een verdere daling van de waarde van het CRV-token kan leiden tot liquidatie van het token.</p>
<p>De reden is dat Agorov CRV als onderpand had gebruikt voor leningen bij verschillende uitleenprotocollen. Sterker nog, hij gebruikte $168 miljoen aan CRV, ongeveer 34% van het totale aanbod, om verschillende leningen te beveiligen.</p>
<p>Bijvoorbeeld, Egorov gebruikte $63 miljoen aan CRV als onderpand voor een lening op Aave. Hij gebruikte ook $32 miljoen aan CRV als onderpand om <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> stablecoin te krijgen op Fraxlend, de stablecoin-uitgever. Hij had ook een lening ter waarde van $18 miljoen op Abracadabra. Volgens DefiLlama zou het onderpand van Egorov’s CRV worden geliquideerd wanneer de waarde ervan $0.37 bereikt.</p>
<p>Na de Curve Finance-exploit heeft Egorov verschillende maatregelen genomen om een mogelijke liquiditeitscrisis te voorkomen, waardoor de waarde van CRV onder de $0,37 zou kunnen dalen. Egorov heeft kapitaal vergroot door LIDO te verkopen, de inheemse token voor Lido, een liquide stakingsplatform. Hij heeft ook enkele van zijn leningen terugbetaald om de impact van een mogelijke liquidatie te verminderen.</p>
<p>Daarnaast bood Curve Finance een beloning van 10% aan voor de teruggave van de gestolen cryptocurrencies. Volgens 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 herstelde met 75%</a> van de gestolen crypto-assets nadat de beloning is aangeboden.</p>
<h2 id="h2-Mogelijke20effecten20van20de20liquidatie20van20Egorovs2016820miljoen17265"><a name="Mogelijke effecten van de liquidatie van Egorov’s $168 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mogelijke effecten van de liquidatie van Egorov’s $168 miljoen</h2><p>Als de CRV-prijs onder de $0,37 zou kunnen dalen, zou dit kunnen leiden tot de liquidatie van Egorov’s leningonderpand van CRV ter waarde van $168 miljoen. Het effect van een dergelijke liquidatie zou verstrekkend zijn, aangezien verschillende uitleenplatforms en Curve Finance te maken zouden krijgen met liquiditeitsuitdagingen.</p>
<p>Bijvoorbeeld, kort na de hack daalde de totale waarde vergrendeld van Curve Finance met ongeveer 44%, terwijl de totale waarde vergrendeld voor de gehele DeFi-sector met meer dan $2 miljard daalde. Zoals we uit deze ontwikkeling kunnen opmerken, zou de liquidatie van de $168 miljoen aan Curve Finance crypto van Egorov een besmettingseffect kunnen hebben op DeFi-protocollen waar CRV als onderpand wordt gebruikt.</p>
<p>De liquidatie van CRV zou leiden tot een massale verkoop tegen een zeer lage prijs, wat de liquiditeit van verschillende cryptoprojecten die ermee omgaan zou beïnvloeden. Op dezelfde manier zou een liquidatie waarschijnlijk de prijs verder omlaag duwen, wat paniek onder investeerders zou kunnen veroorzaken. Het is het vermelden waard dat CRV is gekoppeld aan verschillende cryptocurrencies in verschillende gedecentraliseerde financiële platforms zoals <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>.</p>
<p>Bovendien heeft dit hackincident aangetoond dat geconcentreerd bezit van een crypto-activum in handen van één of enkele personen of entiteiten rampzalige gevolgen kan hebben. Als deze personen grote hoeveelheden van een specifieke token/munt als onderpand gebruiken of in hefboomhandel, kan de liquidatie ervan leiden tot een scherpe daling van de prijs. Dit kan resulteren in massale verkoop en een mogelijke implosie.</p>
<p>Ook, wanneer de gemeenschap van investeerders zich realiseert dat een crypto-activum in handen is van enkele individuen of entiteiten die een negatief sentiment kunnen creëren dat mogelijk een nadelige invloed heeft op de waarde ervan. Dat is de reden waarom veel particuliere beleggers de activiteiten van walvissen volgen om de mogelijke prijsbeweging van specifieke cryptocurrencies te bepalen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/648/what-is-curve-war-gain-insight-into-curve-the-stablecoin-exchange-leader" target="_blank">Wat is Curve War: Inzicht krijgen in Curve - De leider van de Stablecoin Exchange</a></p>
<h2 id="h2-Maatregelen20om20risicos20met20betrekking20tot20cryptoinvesteringen20te20verminderen58406"><a name="Maatregelen om risico’s met betrekking tot crypto-investeringen te verminderen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Maatregelen om risico’s met betrekking tot crypto-investeringen te verminderen</h2><p>De cryptobranche heeft ook waardevolle lessen geleerd van de hacking van Curve Finance en de mogelijke liquidatie van Egorov’s CRV ter waarde van $168 miljoen.</p>
<p>Eerst moeten DeFi-bedrijven gepaste zorgvuldigheid betrachten voordat ze grote leningen aan individuen en entiteiten aanbieden. Zoals opgemerkt in dit g, verzamelde Egorov een derde van de CRV-voorraad om te gebruiken als onderpand voor leningen ter waarde van miljoenen dollars, genoteerd in cryptocurrencies, voornamelijk stablecoins.</p>
<p>De liquidatie van cryptocurrencies die deel uitmaken van het onderpand zou van invloed zijn op de liquiditeit en levensvatbaarheid van de hele DeFi-sector. Daarom moeten uitleenprotocollen de waarde van cryptomiddelen beschermen door grote posities te beperken die systeemrisico’s kunnen creëren.</p>
<p>Cryptoprojecten zouden synergieën en samenwerkingen moeten creëren om de fondsen van investeerders te beschermen. Bijvoorbeeld, de samenwerkingsgeest die getoond werd door de white hat hackers en MEV bot operators is belangrijk omdat ze hebben geholpen om een deel van de gestolen cryptocurrencies terug te krijgen.</p>
<p>Ook het feit dat er door een kwetsbaarheid in de programmeertaal Vyper miljoenen dollars aan cryptocurrencies zijn gestolen, geeft aan dat er behoefte is aan grondige beveiligingsaudits en de implementatie van robuuste beveiligingspraktijken en -en.</p>
<h2 id="h2-Conclusie501373"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Na de hack van Curve Finance was Egorov’s CRV ter waarde van $168 miljoen bedreigd door een mogelijke massale liquidatie. De reden hiervoor is dat Egorov de tokens als onderpand gebruikte voor verschillende cryptoleningen. Een grote liquidatie zou ook invloed hebben gehad op de liquiditeit van verschillende DeFi-platforms die CRV als onderdeel van hun portefeuilles hebben.</p>
<h2 id="h2-Veelgestelde20vragen20over20Curve20Finance861619"><a name="Veelgestelde vragen over Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Curve Finance</h2><h3 id="h3-Wat20is20Curve20Finance518466"><a name="Wat is Curve Finance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Curve Finance?</h3><p>Curve Finance is een gedecentraliseerde uitwisseling waar mensen cryptocurrencies kunnen omwisselen. Iedereen kan zijn/haar crypto-activa in verschillende pools op het platform storten.</p>
<h3 id="h3-Is20Curve20Finance20veilig229631"><a name="Is Curve Finance veilig?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Curve Finance veilig?</h3><p>Curve Finance is veilig omdat het in de loop der jaren niet veel kwaadwillende exploits heeft meegemaakt. Echter, net als elke andere gedecentraliseerde toepassing, kunnen kwaadwillende actoren het op elk moment compromitteren, afhankelijk van de huidige beveiligingspraktijken.</p>
<h3 id="h3-Waarom20CRV20kopen432504"><a name="Waarom CRV kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom CRV kopen?</h3><p>CRV is een bestuur <a href="https://www.gate.io/price/curve-dao-crv" target="_blank">Curve Finance-token</a>, een van de toonaangevende gedecentraliseerde beurzen. Aangezien er een grote vraag is naar de diensten van Curve Finance, is de kans groot dat CRV in de loop van de tijd een stabiele waarde zal behouden. Op dezelfde manier heeft het platform een zeer waardevolle technologie en maken veel handelaren er gebruik van. Lees ook hoe <a href="https://www.gate.io/how-to-buy/curve-dao-crv" target="_blank">Curve DAO kopen</a></p>
<h3 id="h3-Is20CRV20een20goede20investering656516"><a name="Is CRV een goede investering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is CRV een goede investering?</h3><p>CRV is een goede investering, omdat het een gedecentraliseerde exchange ondersteunt waarvan de producten en diensten zeer in trek zijn. Veel crypto-investeerders wisselen duizenden cryptocurrencies uit op Curve Finance.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>