RGFnZWxpamtzIE5pZXV3cyB8IExpdGVjb2luIE9mZmljaWVlbCBHZWhhbHZlZXJkLCA2IEJlZHJpanZlbiwgV2Fhcm9uZGVyIEdyYXlzY2FsZSwgSGViYmVuIEFhbnZyYWdlbiBJbmdlZGllbmQgVm9vciBFdGhlcmV1bSBGdXR1cmVzIEVURidzLCBLZW5pYSBIZWVmdCBEZSBXZXJraW5nIFZhbiBXb3JsZGNvaW4gT3BnZXNjaG9ydCwgRml

2023-08-03, 04:07

<p><img src="https://gimg2.gateimg.com/image/article/16910453210803.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Na20de20halvering20van20Litecoin20was20de20markt20stil20en20zes20bedrijven20zoals20Grayscale20hebben20zich20aangemeld20voor20Ethereum20futures20ETF56024"><a name="Crypto Daily Digest: Na de halvering van Litecoin was de markt stil en zes bedrijven zoals Grayscale hebben zich aangemeld voor Ethereum futures ETF." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Na de halvering van <a href="/price/litecoin-ltc" target="_blank" class="blog_inner_link">Litecoin</a> was de markt stil en zes bedrijven zoals Grayscale hebben zich aangemeld voor <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> futures ETF.</h2><p>Op 2 augustus, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> heeft de blokbeloning voor de derde keer gehalveerd op blokhoogte 2.520.000, van 12,5 LTC naar 6,25 LTC.</p>
<p>Dit is de derde halvering van Litecoin sinds de lancering in 2011. De eerste halvering vond plaats in 2015 en de tweede halvering vond plaats in 2019.</p>
<p>In 2019, toen de laatste halvering van Litecoin plaatsvond, was de prijs van Litecoin ongeveer $90. In 2023, toen Litecoin halveerde, was de munt prijs nog steeds rond de $90.</p>
<p>De stille halvering, de stille markt en het marktsentiment dat zelfs halvering in een bearmarkt niet kan stimuleren, moeten wachten tot het marktvertrouwen hersteld is en de opwaartse trend een reactie kan hebben.</p>
<p>Eric Balchunas, senior ETF-analist van Bloomberg, tweette dat er op dit moment zes bedrijven solliciteren voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures ETF. Naast het indienen van Volatility Shares op 28 juli lokale tijd, dienden Bitwise, Roundhill, VanEck, Proshares en Grayscale op 1 augustus lokale tijd een aanvraag in voor Ethereum Futures ETF. De tijdslimiet voor de SEC om te beslissen over de aanvraag van Volatility Shares is 11 oktober, en de tijdslimiet voor het nemen van beslissingen over de aanvraag van de andere vijf Ethereum-futures ETF’s is 16 oktober.</p>
<p>De Ethereum Futures ETF’s die worden aangevraagd door zes bedrijven zijn Ether Strategy ETF, Bitwise Ethereum Strategy ETF, Roundhill Ethereum Strategy ETF, Ethereum Strategy ETF, Proshares Short Ethereum Strategy ETF en Grayscale Ethereum Futures ETF (ETHG).</p>
<p>Volgens CoinDesk heeft het Keniaanse Ministerie van Binnenlandse Zaken woensdag een verklaring vrijgegeven op haar Facebook-pagina waarin staat dat het de werking van Worldcoin heeft opgeschort. De verklaring ondertekend door Minister Kithure Kindiki verklaarde: “De regering maakt zich zorgen over de voortdurende activiteiten van een organisatie die beweert ‘WORLD COIN’ te zijn, die oog-/irisgegevens verzamelt voor burgerregistratie.” De relevante financiële, beveiligings- en gegevensbeschermingsdiensten zijn begonnen met een onderzoek om de wettigheid en gegevensbescherming van het project vast te stellen.</p>
<p>Gameverkoper GameStop heeft verklaard dat het de ondersteuning voor zijn cryptowallets zal stopzetten vanwege “regelgevingsonzekerheid.” Volgens de website van het bedrijf zal GameStop zijn iOS- en Chrome-extensiewallets vanaf 1 november van de markt verwijderen, waarmee gebruikers hun cryptocurrency en NFT kunnen beheren. De stap markeert dat GameStop zijn cryptocurrencystrategie opgeeft.</p>
<p>Het bedrijf zei dat het zich niet langer zou richten op cryptocurrency na een nett verlies van $94,7 miljoen in het derde kwartaal van vorig jaar en ontslagen op de afdeling digitale activa. GameStop lanceerde een jaar geleden de NFT-markt, waardoor spelers, makers, verzamelaars en andere leden van de gemeenschap NFT’s kunnen kopen, verkopen en verhandelen.</p>
<p>Volgens de NFT verkoopgegevens bijgehouden door CryptoSlam op 21 blockchains, bedroegen de totale NFT verkopen in juli ongeveer $492 miljoen. Van deze verkopen kwam 55% van de NFT verkopen op de Ethereum keten, ongeveer $270 miljoen. De op één na grootste blockchain in NFT verkopen is <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Chain, met in totaal $64,92 miljoen; Daarna komen <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>($37,61 miljoen), <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ($24.58 miljoen), en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> ($23.43 miljoen).</p>
<p>Volgens Defillama-gegevens is de Base Network TVL nu gedaald tot $6,96 miljoen, een daling van 83% ten opzichte van de piek van $41,2 miljoen op 31 juli, mogelijk als gevolg van de terugtrekking van liquiditeit door het BALD-projectteam van meme-token en het LeetSwap-hackincident.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens287938"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC667280"><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/1691045357BTC.png" alt=""><br>Na kortstondig de $30.000 grens te hebben aangeraakt gisteren, zakte het naar het $29.000 niveau. De korte termijn strategie blijft gericht op de opwaartse trendlijn. Risicovolle bullish instapstrategie: $28.550; risicovolle bearish instapstrategie: $27.950 met voortdurende observatie tot het $26.500 niveau.</p>
<h3 id="h3-ETH668344"><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/1691045375ETH.png" alt=""><br>Voor agressieve kortetermijnaanbevelingen, observeer of het stabiliseert boven de opwaartse trend. Als het stabiel blijft en blijft stijgen, kan het worden beschouwd als een signaal om een longpositie in te nemen. Voor conservatieve kortetermijnstrategieën wachten we nog steeds op een doorbraak van $2.037 met een voortdurend opwaarts doel van $2.358. Let op dat de huidige trend nog steeds bearish is.</p>
<h3 id="h3-CRV703451"><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/1691045394CRV.png" alt=""><br>Curve-oprichter Michael Egorov heeft zich beziggehouden met over-the-counter-transacties met verschillende waarden (in totaal $ 14,5 miljoen) voor CRV, met een OTC-gemiddelde prijs van ongeveer $ 0,4 per USD. Kortetermijn-CRV vertoont een zeldzame bullish structuur van de “oplopende schouderbodem”, met opwaartse doelen van $ 0,608, $ 0,639 en $ 0,68 per USD.</p>
<h2 id="h2-Macro20Fitch20Ratings20verlaagt20de20kredietwaardigheid20van20de20VS20mogelijk20van20invloed20op20de20mondiale20financile20markten237797"><a name="Macro: Fitch Ratings verlaagt de kredietwaardigheid van de VS, mogelijk van invloed op de mondiale financiële markten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fitch Ratings verlaagt de kredietwaardigheid van de VS, mogelijk van invloed op de mondiale financiële markten</h2><p>Fitch, een van ‘s werelds drie grootste kredietbeoordelingsbedrijven, heeft aangekondigd de kredietwaardigheid van de Verenigde Staten te verlagen, wat het grootste nieuws is in de mondiale kapitaalmarkten en financiële markten van de afgelopen twee dagen.</p>
<p>Fitch legde uit dat de belangrijkste reden voor hun verlaging van de kredietwaardigheid van de VS te wijten is aan de steeds zwaardere schuldenlast en politieke disfunctie van de VS. Ze hebben de kredietwaardigheid van de Verenigde Staten met één stap verlaagd van de vorige AAA-rating naar AA+.</p>
<p>De verlaging van de kredietwaardigheid heeft een enorme impact op de wereldwijde kapitaalmarkt omdat de Amerikaanse schatkistobligaties een belangrijke rol spelen op de wereldmarkt. Het wordt beschouwd als een veilige havenbeveiliging met bijna geen risico op rendement en is de meest betrouwbare beveiliging ter wereld.</p>
<p>De Amerikaanse overheid leent geld om vele goedkope en duurzame schuldfondsen te verhogen door het uitgeven van een schatkistobligatie. Echter, nadat de kredietwaardigheid is verlaagd, zal de kosten van Amerikaanse schatkistobligaties toenemen en zal ook de kosten van lenen door de Amerikaanse overheid stijgen, waardoor het vermogen tot herfinanciering verzwakt en een enorme impact heeft op de wereldwijde financiële markt.</p>
<p>Van de drie belangrijkste ratingbureaus ter wereld heeft S&amp;P de kredietwaardigheid van de Amerikaanse overheid al in 2011 met één niveau verlaagd vanaf het hoogste niveau. En een andere ratingmaatschappij, Moody’s, blijft de Verenigde Staten de hoogste rating geven.</p>
<p>De reactie van de Biden-regering op dit incident benadrukte twee punten. Ten eerste geloven ze dat de beoordelingsbeslissing van Fitch willekeurig is, omdat deze is gebaseerd op verouderde gegevens en lijkt de risico’s van politieke strijd en de verbeterde capaciteit van de Amerikaanse overheid om voor zichzelf te zorgen te onderschatten. Ten tweede verklaarde de Biden-regering dat Fitch vóór dit besluit verschillende communicaties met de Amerikaanse overheid had gehad, maar dat Fitch nog steeds vasthield aan haar beslissing.</p>
<p>Wat betreft de opvattingen van investeerders en economen, gelooft sommigen dat een verlaging van de rating geleidelijk het vertrouwen van de wereldwijde financiële markten in de kredietwaardigheid van de Amerikaanse overheid zal verminderen. Hoewel de effectenmarkt enigszins beïnvloed zou kunnen worden, zal de impact niet zo significant zijn als in 2011, aangezien de Federal Reserve al renteverhogingen heeft doorgevoerd en ruimte heeft om ze te verlagen.</p>
<p>Vanwege de aanzienlijke stijging van de aandelenmarktwaarderingen, met name in de technologiesector, zijn sommige mensen bezorgd dat een afwaardering een grotere impact kan hebben op de overgewaardeerde technologiesector.</p>
<p>Over het algemeen zal de impact van de markt op de verlaging van de kredietwaardigheid van de VS door Fitch verder broeien en rustig waarnemen vereisen.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>