RGFnZWxpamtzIG5pZXV3cyB8IEN1cnZlLWhhY2tlbiBrYW4gd29yZGVuIG9uZGVyc3RldW5kIGRvb3Igc29tbWlnZSBsYW5kZW4sIGhldCBncm9vdHN0ZSBNRVYtYmVsb25pbmdzYmxvayBpbiBkZSBnZXNjaGllZGVuaXMgdmFuIEV0aGVyZXVtIGlzIGdlZ2VuZXJlZXJkLCBmb2N1cyBvcCBkZSA3IGJlc3RlIHByb2plY3RlbiBkaWUgdG9

2023-08-01, 04:02

<p><img src="https://gimg2.gateimg.com/image/article/16908706700801.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Curve20hacking20kan20worden20ondersteund20door20sommige20landen20en20kan20worden20gehackt20vanwege20een20Vyper20versie20fout20kwetsbaarheid20het20grootste20MEV20beloningsblok20in20de20geschiedenis20van20Ethereum20is20gegenereerd889310"><a name="Crypto Dagelijkse Samenvatting: Curve hacking kan worden ondersteund door sommige landen en kan worden gehackt vanwege een Vyper versie fout kwetsbaarheid, het grootste MEV beloningsblok in de geschiedenis van Ethereum is gegenereerd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Curve hacking kan worden ondersteund door sommige landen en kan worden gehackt vanwege een Vyper versie fout kwetsbaarheid, het grootste MEV beloningsblok in de geschiedenis van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is gegenereerd.</h2><p>Vandaag zei @fubuloubu, een bijdrager aan de smart contract taal Vyper, als reactie op de Curve hack, “Het zal enkele weken tot enkele maanden duren om de kwetsbaarheid te vinden, misschien door een Clique of team. We kunnen binnenkort meer informatie vinden, maar gezien de geïnvesteerde middelen, denk ik dat het redelijk is om te vermoeden dat hackers die door de staat worden ondersteund eraan deelnemen.”</p>
<p>23pds, de Chief Information Security Officer van SlowMist, verklaarde dat het officiële document dat aanbevolen wordt door Vyper eigenlijk een onjuiste versie is.</p>
<p>Volgens het vorige rapport, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De programmeertaal Vyper heeft aangekondigd dat Vyper-versies 0.2.15, 0.2.16 en 0.3.0 een kwetsbaarheid met betrekking tot een recursieve vergrendeling hadden bij functiefouten. We zijn momenteel aan het onderzoeken, maar projecten die deze versies gebruiken, moeten onmiddellijk contact met ons opnemen.</p>
<p>De officiële reactie van Curve verklaarde dat vanwege een kwetsbaarheid in Vyper 0.2.15 sommige stablecoin-pools (alETH/msETH/PATH) zijn gehackt. We ueren de situatie en zullen updates vrijgeven aan de gemeenschap naarmate de situatie zich ontwikkelt. De andere pools zijn veilig.</p>
<p>Volgens DefiLlama-gegevens is het totale lock-up volume (TVL) van Curve Finance gedaald van $3,266 miljard op 30 juli tot de huidige $1,869 miljard, een daling van 42,78% in 24 uur als gevolg van de hack.</p>
<p>Als gevolg van de hack werden op 31 juli enkele van de grootste MEV-beloningen in de geschiedenis van Ethereum gegenereerd. Daarvan ontving Slot 6.992.273 584 ETH beloningen; Slot 6.993.342 ontving 345 ETH beloningen; Slot 6.992.050 ontving 247 ETH beloningen; Slot 6.993.346 ontving 51 ETH beloningen.</p>
<p>Eric.eth legde verder uit dat vanwege een hacker aanval op Curve, een robot een hackerindringing in de MEV pool opmerkte, tx kopieerde en ervandoor ging. Hiervoor betalen ze een grote hoeveelheid ETH aan block producers om een concurrentievoordeel te behalen.</p>
<p>Volgens mevboost.pics was gisteren de meest winstgevende dag voor MEV-prijzen sinds Ethereum vorig jaar fuseerde. Er wordt geschat dat er 600.623 ETH ($11,1 miljoen) is betaald aan de verifier als MEV-prijzen. Het vestigde een recordhoogte, hoger dan de vorige 5.103,75 ETH op 11 mei.</p>
<p>Volgens de gegevens van Token Unlocks zal er deze week een eenmalige ontgrendeling zijn van 7 cryptoprojecten, waaronder <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, Galxe, Acala, Nym, Liquid, Tornado Cash en Eluer, met een totale ontgrendelingswaarde van ongeveer $26,976 miljoen.</p>
<p>dYdX ontgrendelde 6,52 miljoen tokens (ongeveer $13,56 miljoen) om 15:00 uur (UTC) op 1 augustus, wat overeenkomt met 3,81% van het totale aanbod;</p>
<p>Galxe ontgrendelde 7,61 miljoen tokens (ongeveer $9,75 miljoen) om 12:00 uur (UTC) op 5 augustus, goed voor 16,51% van het totale aanbod;</p>
<p>Acala ontgrendelde 27,43 miljoen tokens (ongeveer $1,81 miljoen) om 7:00 uur (UTC) op 1 augustus, wat overeenkomt met 3,56% van het totale aanbod;</p>
<p>Nym heeft 3,13 miljoen tokens ontgrendeld (ongeveer $620.000) om 00:00 uur (UTC) op 4 augustus, wat overeenkomt met 0,66% van het totale aanbod;</p>
<p>Liquid ontgrendelde 657.300 tokens (ongeveer $736.000) om 00:00 uur (UTC) op 5 augustus, wat overeenkomt met 0,71% van het totale aanbod;</p>
<p>Tornado Cash ontgrendelde 22.800 tokens (ongeveer $80.600) om 11:06 uur (UTC) op 5 augustus, wat neerkomt op 1,51% van het totale aanbod;</p>
<p>Eluer ontgrendelde op 2 augustus om 11:42 uur (UTC) ongeveer 156.200 tokens ter waarde van $420.200, wat overeenkomt met 0,84% van het totale aanbod.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag856074"><a name="Belangrijkste Token Trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van vandaag</h2><h3 id="h3-BTC378283"><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/1690870913BTC.png" alt=""><br>Aan het einde van de maand opende BTC op $29,2K en vertoonde een bearish trend met een zwak volume van fondsen binnen de markt. Het korte termijn perspectief blijft bearish met een duidelijk head-and-shoulders patroon, en er wordt een bearish strategie voorgesteld, waarbij gewacht wordt op een retracement naar $28,5K en de paarse trendlijn.</p>
<h3 id="h3-ETH927287"><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/1690870723ETH.png" alt=""><br>ETH’s opening aan het begin van de maand brak onder de neklijn op $1.857, en op korte termijn ligt de focus op de vraag of het terug zal zakken naar $1.833. Als dat zo is, zal het hoofd-en-schouderpatroon bevestigd worden, en zou het naar beneden kunnen blijven gaan richting het doel van $1.755. De korte termijn trend is bearish.</p>
<h3 id="h3-CRV145524"><a name="CRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CRV</h3><p><img src="https://gimg2.gateimg.com/image/article/1690870741CRV.png" alt=""><br>CRV blijft negatieve factoren tegenkomen, resulterend in een crash op de secundaire markt. Het eerste doel op $0,558 is doorbroken. Mensen die short zijn gegaan op $0,608 moeten letten op verdere doelen op $0,541, $0,527, $0,517 en sterke ondersteuning op $0,477.</p>
<h2 id="h2-Macro20De20rentebeslissing20van20september20blijft20onbeslist20en20de20Federal20Reserve20is20ervan20overtuigd20dat20ze20een20zachte20landing20voor20de20economie20kunnen20realiseren610624"><a name="Macro: De rentebeslissing van september blijft onbeslist, en de Federal Reserve is ervan overtuigd dat ze een zachte landing voor de economie kunnen realiseren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De rentebeslissing van september blijft onbeslist, en de Federal Reserve is ervan overtuigd dat ze een zachte landing voor de economie kunnen realiseren</h2><p>Gisteren daalde de spotgoudprijs eerst en steeg vervolgens, bleef tijdens de sessie nauwelijks op het niveau van $1.950 en begon zijn opwaartse trend in de pre-US-sessie. Het steeg kortstondig naar een intraday hoogtepunt van $1.972,50 en sloot uiteindelijk 0,3% hoger op $1.965,16 per ounce, waarmee het zijn beste maandelijkse prestatie in vier maanden neerzette; Spotzilver steeg voorafgaand aan de Amerikaanse markt met goud, steeg tijdens de sessie met meer dan 2% voordat het 1,7% hoger sloot op $24,76 per ounce.</p>
<p>De Amerikaanse Dollar Index eindigde de dag met een gemengde trend met een stijging van 0,16% tot 101,86. Maar op de maandelijkse lijn sloot de Amerikaanse index voor de tweede opeenvolgende maand groen. De Amerikaanse obligatierendementen stegen eerst en daalden vervolgens, waarbij het rendement op de Amerikaanse obligatie met een looptijd van twee jaar daalde tot een intraday-laagtepunt van 4,843% en uiteindelijk sloot op 4,885%; Het rendement op de Amerikaanse schatkist met een looptijd van 10 jaar werd belemmerd op het niveau van 4% en sloot uiteindelijk op 3,967%.</p>
<p>Op de laatste handelsdag van juli op de Amerikaanse aandelenmarkt schommelden de drie belangrijkste aandelenindices gedurende de dag nauwelijks, waarbij de Dow 0,28% hoger sloot, de Nasdaq 0,21% hoger sloot en de S&amp;P 500-index met 0,15% steeg.</p>
<p>Voorzitter van de Chicago Fed, Austan Goolsbee, die wordt beschouwd als een van de meer duifachtige beleidsmakers van de Federal Reserve, verklaarde dat de Fed goed werk heeft verricht door de inflatie te vertragen en dat een zachte landing mogelijk is. Maar hij bepaalt momenteel nog steeds de beleidsbeslissing voor september.</p>
<p>Goolsbee zei: ‘Het gouden pad dat we tot nu toe hebben gevolgd is zeker mogelijk, en dit zal een overwinning zijn,’ verwijzend naar het vermogen om inflatie te bereiken tot de doelen van de Federal Reserve zonder een recessie te veroorzaken.</p>
<p>Hij verklaarde dat de gegevens die een vertraging in de disinflatie in de Verenigde Staten laten zien, ‘uitstekend nieuws’ waren. Toch had hij nog niet besloten of hij de opschorting van renteverhogingen op de volgende beleidsvergadering zou steunen.</p>
<p>De Amerikaanse economie heeft ondanks de aanzienlijke verstrakking van het beleid door de Federal Reserve haar veerkracht behouden, wat economen en andere particuliere sectorcollega’s bij de Federal Reserve ertoe heeft aangezet om oproepen voor een economische recessie uit hun voorspellingen te verwijderen.</p>
<p>Voorzitter van de Minneapolis Federal Reserve, Neel Kashkari, verklaarde ook op zondag dat de Federal Reserve nu gelooft dat het de economie kan leiden naar een zogenaamde zachte landing.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<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 zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>