RGFnZWxpamtzIG5pZXV3cyB8IEN1cnZlIEZpbmFuY2Ugd2VyZCBnZWhhY2t0IGVuIHZlcmxvb3IgbWVlciBkYW4gJDUyTTsgSGV0IG1hYW5kZWxpamtzZSBoYW5kZWxzdm9sdW1lIHZhbiBDTUUgQlRDLWZ1dHVyZXMgYmVyZWlrdGUgZWVuIGphYXJsaWprcyBob29ndGVwdW50OyBNaWNoYWVsIFNheWxvciB2ZXJrbGFhcmRlIGRhdCBoZXQ

2023-07-31, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/16907837350731.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Curve20Finance20is20gehackt20Het20maandelijkse20handelsvolume20van20CME20Bitcoin20futures20bereikte20een20jaarlijks20hoogtepunt20Michael20Saylor20verklaarde20dat20het20marktaandeel20van20BTC20zal20stijgen20naar2080259603"><a name="Crypto Dagelijkse Samenvatting: Curve Finance is gehackt; Het maandelijkse handelsvolume van CME Bitcoin futures bereikte een jaarlijks hoogtepunt; Michael Saylor verklaarde dat het marktaandeel van BTC zal stijgen naar 80%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Curve Finance is gehackt; Het maandelijkse handelsvolume van CME <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> futures bereikte een jaarlijks hoogtepunt; Michael Saylor verklaarde dat het marktaandeel van BTC zal stijgen naar 80%</h2><p>In de vroege ochtend van 31 juli, het officiële Twitter-account van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> EVM-compiler Vyper tweette dat Vyper-versies 0.2.15, 0.2.16 en 0.3.0 kwetsbaar zijn voor recursieve vergrendelingsfouten. Het onderzoek loopt nog, maar elk project dat vertrouwt op deze versies moet onmiddellijk contact opnemen met het team. Vervolgens tweetten veel gerelateerde protocollen over hackingevenementen die werden beïnvloed door gerelateerde problemen, waarbij Curve Finance bijzonder kwetsbaar was voor misbruik van kwetsbaarheden.</p>
<p>Volgens een tweet van Curve Finance zijn veel stablecoin-pools (alETH/msETH/PATH) die Vyper 0.2.15 gebruiken gehackt vanwege de fout in recursieve sloten. Het team ueert de situatie en zal de gemeenschap updaten naarmate de situatie zich ontwikkelt. CrvUSD-futures en andere fondspools worden niet beïnvloed.</p>
<p>Eerder kondigde de Ethereum-programmeertaal Vyper aan dat de recursieve sloten van Vyper versie 0.2.15, 0.2.16 en 0.3.0 ongeldig waren, wat momenteel wordt onderzocht.</p>
<p>Beïnvloed door de hack, de prijs van <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a>‘s inheemse token CRV daalde op een gegeven moment naar $0.59 en staat momenteel op $0.64, een daling van ongeveer 13% in 24 uur.</p>
<p>Als gevolg hiervan bedreigt de kwetsbaarheid van Vyper rechtstreeks de DeFi van het hele Ethereum-ecosysteem. Als alle projecten deze versies hebben bijgewerkt, zal het een enorme ramp zijn voor DeFi.</p>
<p>Op 30 juli 2015 werd het Ethereum-mainnet officieel gelanceerd en werd er een Genesis-blok gegenereerd. Het eerste blok bevat 8.893 transacties en levert blokbeloningen van 5ETH op. Momenteel draait het Ethereum-mainnet al 8 jaar.</p>
<p>Volgens de on-chain data heeft het totale aantal transacties van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> momenteel meer dan 2,05 miljard Txns overschreden, het totale aantal adressen heeft 296 miljoen bereikt, het aantal futures-adressen heeft 61,61 miljoen bereikt en het totale handelsvolume heeft 9,93 miljard ETH bereikt.</p>
<p>Hoewel de handelsvolume van cryptocurrency-handelsplaatsen en -beurzen is afgenomen, heeft CME Group in juli het hoogste maandelijkse handelsvolume van dit jaar behaald.</p>
<p>Het handelsvolume van de Bitcoin-futuresmarkt op de Chicago Mercantile Exchange (CME) bereikte in april het hoogste niveau, met nog maar één handelsdag te gaan in juli, met een handelsvolume van $53,33 miljard. In april bereikte het handelsvolume van het bedrijf $53,06 miljard.</p>
<p>Op 29 juli bedroegen de open posities op de CME Bitcoin futures-markt $2,5 miljard, wat aangeeft dat de markt zeer populair is bij institutionele beleggers zoals hedgefondsen en grote handelsbedrijven.</p>
<p>Onlangs heeft Michael Saylor, voormalig CEO van MicroStrategy, in een interview commentaar geleverd dat de SEC momenteel platforms zoals Coinbase en Binance aanklaagt, waarvan hij gelooft dat dit mogelijk ongekende ontwikkelingskansen voor Bitcoin met zich mee kan brengen. Momenteel is het marktaandeel van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in cryptocurrency bevindt zich tussen de 40% en 48%. Michael Saylor voorspelt dat het marktaandeel van bitcoin in de toekomst zal stijgen naar een verbazingwekkende 80%, en de overige altcoins zullen slechts goed zijn voor de overige 20%.</p>
<p>Michael Saylor gelooft dat omdat een groot aantal cryptocurrency-handelsplatforms bang is voor de SEC en altcoins zal laten schrappen die als effecten kunnen worden beschouwd, Bitcoin de ultieme kracht van cryptocurrency zal worden.</p>
<p>Het ontwikkelingsmomentum van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> in Hong Kong is booming. Sinds de publicatie van de “Beleidsverklaring over de ontwikkeling van virtuele activa in Hong Kong” in oktober vorig jaar, hebben 90 ondernemingen op het vasteland en in het buitenland die verband houden met virtuele activa interesse getoond om zich in Hong Kong te vestigen. De regering van Hongkong heeft medio dit jaar een uitgebreid licentiesysteem opgezet voor aanbieders van virtuele activadiensten, dat helpt om de stabiele en ordelijke ontwikkeling van de markt te waarborgen en de belangen van beleggers te beschermen.</p>
<p>Op regelgevingsniveau zijn er vaak acties geweest.</p>
<p>Onlangs heeft de president van Peru een nieuw decreet uitgevaardigd waarin staat dat alle cryptocurrency-uitwisselingen die in het land actief zijn, moeten voldoen aan de regels inzake de bestrijding van het witwassen van geld (AML). Volgens de wet moeten aanbieders van virtuele activadiensten, inclusief individuen en bedrijven die actief zijn in Peru, nu informatie rapporteren aan de Financial Intelligence Unit (UIF-Peru). Deze afdeling is verantwoordelijk voor het ontvangen, analyseren en verzenden van informatie om activiteiten in verband met het witwassen van geld en financiering van terrorisme te identificeren.</p>
<p>Hoewel de wet nu van kracht is, wordt verwacht dat UIF-Peru in de komende dagen meer specifieke richtlijnen zal publiceren om de verplichtingen en verantwoordelijkheden van aanbieders van virtuele activadiensten in het land verder te verduidelijken.</p>
<p>De Amerikaanse Congresleden Gus Bilirakis (Republikein van de Republikeinse Partij van Florida) en Jan Schakowsky (Democraat van Illinois) hebben een brief gestuurd naar Tim Cook, CEO van Apple, waarin ze vragen of de App Store-gids van Apple opkomende technologieën heeft gedood, zoals gedistribueerde grootboektechnologie en NFT’s.</p>
<p>Volgens de Hindustan Times heeft het Hooggerechtshof van India de federale regering opgedragen aan te geven of zij van plan is een federale instantie op te richten om strafzaken met betrekking tot cryptocurrency te onderzoeken, en zei dat het ‘betreurenswaardig’ is dat India tot nu toe nog geen wetten of instellingen heeft om cryptocurrency te reguleren.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag177590"><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-BTC506893"><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>In de afgelopen week heeft BTC voortdurend vastgehouden aan het ondersteuningsniveau van $29,500 USD en de bullish strategie wacht op een doorbraak op $30,888 USD om longposities in te stellen, met het belangrijkste doel ingesteld op $36,000 USD. Het bearish scenario zou de uptrend kunnen testen door terug te trekken naar de ondersteuning op $28,500 USD.</p>
<h3 id="h3-ETH932076"><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>De afgelopen week heeft ETH steun gehouden op $1.857 USD en is van plan binnen de opwaartse trend te blijven. Op korte termijn moet aandacht worden besteed aan mogelijke terugtrekkingen naar de trendlijn. Een conservatieve bullish benadering zou zijn om te wachten op een doorbraak op $2.037 USD om posities in te voeren met een winstdoelstelling van $2.358 USD, met behulp van een risico-rendementsstrategie.</p>
<h3 id="h3-WLD127634"><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>Op korte termijn bestaat de mogelijkheid dat er een duidelijk stijgend driehoekspatroon ontstaat. Een conservatieve bullish aanpak suggereert om te wachten op een doorbraak op $2,55 USD om posities in te nemen, met de volgende doelen: $2,785 USD, $3,35 USD en een hoogste doel van $4,3 USD.</p>
<h2 id="h2-Macro20De20Federal20Reserve20is20bullish20over20de20toekomstige20economie20met20de20focus20op20de20nonfarm20data20van20deze20vrijdag934674"><a name="Macro: De Federal Reserve is bullish over de toekomstige economie, met de focus op de non-farm data van deze vrijdag." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve is bullish over de toekomstige economie, met de focus op de non-farm data van deze vrijdag.</h2><p>Volgens gegevens die vrijdag zijn vrijgegeven, noteerde de PCE-kernprijsindex in de Verenigde Staten in juni een jaarcijfer van 4,10%, lager dan de verwachte 4,20% en 4,6%, de kleinste stijging sinds september 2021; Het maandelijkse tarief noteerde 0,2%, wat in lijn is met de verwachtingen en de kleinste stijging sinds november 2022.</p>
<p>Ondertussen registreerde de arbeidskostenindex in de Verenigde Staten een kwartaalpercentage van 1% in het tweede kwartaal, lager dan de verwachte 1,10% en 1,2% van de vorige waarde.</p>
<p>Reflecterend op de geleidelijke koeling van de Amerikaanse arbeidsmarkt. Hoewel de frequentie van de publicatie van de ECI verschilt van de inkomensindicatoren in rapporten over niet-agrarische werkgelegenheid, geven economen er vaak de voorkeur aan omdat het niet zal veranderen als gevolg van veranderingen in de werkgelegenheidssamenstelling van verschillende beroepen of industrieën.</p>
<p>Uit institutionele analyse blijkt dat het PCE-rapport goed presteerde, met een afgenomen inflatie die de marktverwachtingen overtrof. De algehele PCE-prijsindex in de Verenigde Staten daalde ook naar een jaarlijks tarief van 3,0% in juni, wat geen problemen zou moeten veroorzaken op de markt.</p>
<p>Ontinflatie en matige groei in de consumentenbestedingen hebben de kans vergroot dat de economie het zachte landingsscenario dat door beleidsmakers is voorzien, zal bereiken. Donderdag en vrijdag toonden de gegevens aan dat de Amerikaanse economische gegevens voor de eerste helft van 2023 ver boven de marktverwachtingen uitkwamen, wat de Federal Reserve optimistischer kan maken over de economie en ruimte kan bieden voor verdere aanscherping van het beleid.</p>
<p>Belangrijke Evenement Voorspelling voor Deze Week:</p>
<p>Op dinsdag 1 augustus om 11:34 (UTC) werd de Ethereum-sidechain <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a> Chain zal de upgrade van het mainnet Shapella starten op Slot 10379264 (epoch 648704);</p>
<p>Op woensdag 2 augustus lanceerde Cosmos Eco EVM Compatibility Chain <a href="/price/evmos-evmos" rel="nofollow noopener noreferrer" target="_blank">Evmos</a> zal <a href="/price/evmos-evmos" target="_blank" class="blog_inner_link">Evmos</a> 2.0 lanceren</p>
<p>Op donderdag 3 augustus om 09:40 (UTC), <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> wordt verwacht te halveren. De blokbeloning zal worden verlaagd van 12,5 LTC naar 6,25 LTC.</p>
<p>Op dit moment is de activiteit ‘Wie is de Gate.io’s Prophecy Emperor: Raad de LTC-prijs om $25.000 aan LTC-prijzen te delen’ momenteel aan de gang. We verwelkomen iedereen om actief deel te nemen. Raad nu!</p>
<p>Op vrijdag 4 augustus om 12:30 uur (UTC): De Verenigde Staten zal de niet-agrarische gegevens van juli vrijgeven en de markt voorspelt dat de werkloosheidscijfer 3,6% zal bedragen, met een toename van 225.000 banen.</p>
<p>Op zaterdag 5 augustus om 00:00 uur (UTC) zal Tornado Cash (TORN) meer dan 175.000 TORNs vrijgeven, wat overeenkomt met 1,75% van de totale uitgifte.</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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>