RGFnZWxpamtzIG5pZXV3cyB8IFZlcndhY2h0aW5nZW4gdm9vciByZW50ZXZlcmxhZ2luZyBkb29yIGRlIEZlZCB3b3JkZW4gc3RlcmtlciwgdHJlbmRzIG9wIGRlIGNyeXB0b21hcmt0IG5vZyBzdGVlZHMgb25kdWlkZWxpams=

2024-08-22, 04:38

<p><img src="https://gimg2.gateimg.com/image/article/172430132222.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Vitalik20gedwongen20om20publiekelijk20te20pleiten20voor20ETH20Handelsvolume20op20Layer20220Network20neemt20aanzienlijk20af332854"><a name="Crypto Dagelijkse Samenvatting: Vitalik “gedwongen” om publiekelijk te pleiten voor ETH, Handelsvolume op Layer 2 Network neemt aanzienlijk af" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Vitalik “gedwongen” om publiekelijk te pleiten voor ETH, Handelsvolume op Layer 2 Network neemt aanzienlijk af</h2><p>Volgens gegevens van Farside Investor is de totale instroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De handel in spot-ETF’s bedroeg gisteren ongeveer $39 miljoen, waarbij de meeste ETF’s een kleine instroom hadden.</p>
<p>Gisteren was er in het algemeen een uitstroom van geldmiddelen uit de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De handelsvolume van de spot ETF bedroeg ongeveer $18 miljoen. Het algehele handelsvolume van de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF was relatief klein en de instroom van fondsen was ook relatief klein. De prestaties van ETH ETF vielen ver onder de verwachtingen.</p>
<p><strong>Notulen vergadering Federal Reserve: “overgrote meerderheid van de leden” gelooft dat renteverlaging in september gepast kan zijn</strong></p>
<p>Volgens de gisteravond vrijgegeven notulen van de Federal Reserve gelooft de ‘overgrote meerderheid van de leden’ dat een renteverlaging in september passend kan zijn. Het opwaartse risico van inflatie is verminderd. Bijna alle leden geloven dat de daling van de inflatie zal aanhouden. Maar het risico van een afname van de werkgelegenheid wordt geacht te zijn toegenomen. Veel deelnemers wezen erop dat het te laat of te weinig versoepelen van het beleid de economische activiteit of werkgelegenheid buitensporig zou kunnen verzwakken.</p>
<p>Na de publicatie van de notulen van de Federal Reserve steeg <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> opnieuw boven de $60.000 en staat nu geprijsd op $60.031. Volgens marktgegevens daalde de Amerikaanse dollarindex (DXY) onder de 101 na de publicatie van de notulen van de Federal Reserve en nadert daarmee het dieptepunt van het begin van het jaar.</p>
<p><strong>De opbrengst van het ZKsync Era-netwerk daalde met 90% na de airdrop, met minder dan $7.000 aan opbrengsten afgelopen zondag.</strong></p>
<p>Volgens gegevens van The Block is de Layer 2-schaaloplossing ZKsync Era gekelderd na een luchtdaling op 24 juni, waarbij de inkomsten afgelopen zondag daalden tot slechts $6.800, in schril contrast met het hoogtepunt van $746.000 aan dagelijkse inkomsten vóór de luchtdaling (een daling van 99,088%). Bovendien heeft deze luchtdaling een grootschalig verlies van gebruikers en liquiditeit op het netwerk veroorzaakt, waarbij het dagelijkse transactievolume daalde van een hoogtepunt van 1,8 miljoen naar slechts 200.000.</p>
<p>The Block stelde dat deze situatie niet alleen is voorgekomen in het ZKsync-tijdperk, een Layer 2-project, maar dat de GML2-index die Layer 2-tokens bijhoudt, met 66% is gedaald vanaf het hoogtepunt in maart, wat aangeeft dat de hele sector voor uitdagingen staat. De neerwaartse trend na airdrops heeft twijfels doen rijzen over de effectiviteit van tokentoewijzingsstrategieën in de huidige marktomgeving. Hoewel airdrops tot doel hebben om vroege adoptanten te belonen en netwerkeffecten te sturen, lijken ze steeds vaker korte termijn speculatie te veroorzaken, gevolgd door snelle verkoop.</p>
<p><strong>Ethereum medeoprichter Vitalik “gedwongen” om openlijk te pleiten voor ETH</strong></p>
<p>Gisteren plaatste Vitalik Buterin, mede-oprichter van Ethereum, op sociale media dat veel mensen hem altijd adviseren om minder ‘filosofische gedachten’ te delen en meer ‘bullish standpunten’ over Ethereum. Daarom plaatste hij deze tweet.</p>
<p>Vervolgens verklaarde Vitalik Buterin dat deze tweet over ‘bullish Ethereum’ slechts drie minuten kostte en zijn zojuist gepubliceerde 11.700 woorden tellende filosofische blogpost overtrof wat betreft interactie.</p>
<h2 id="h2-Markttrends20BTC20doorbreekt206150020FTM20en20MATIC20presteren20indrukwekkend20in20Coin20Swapconcepten932183"><a name="Markttrends: BTC doorbreekt $61.500, FTM en MATIC presteren indrukwekkend in Coin Swap-concepten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC doorbreekt $61.500, FTM en MATIC presteren indrukwekkend in Coin Swap-concepten</h2><h3 id="h3-Gangbare20Munten986830"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC brak vanochtend kort door $61.500 heen, maar hoewel het later weer terugviel, bevindt het zich nog steeds in de buurt van het midden van de dagelijkse Bollinger Bands. De trend in de komende dagen moet nauwlettend worden gevolgd, vooral of het kan stabiliseren op deze kritieke technische positie.</p>
<p>ETH ervaart momenteel kleine schommelingen rond $2.600 en is er niet in geslaagd om uit een onafhankelijke markttrend te breken. Hoewel ETH spot ETFs enige marktaandacht hebben getrokken, is er geen significante toename van kapitaalinstroom geweest en is het moeilijk om op korte termijn een significante stijging te zien.</p>
<p>De algemene trend van Altcoins is de algemene stijging van de markt gevolgd, met <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> (FTM) en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>(MATIC) presteert bijzonder goed en wordt daarmee de meest populaire altcoin met de beste winsten.</p>
<h3 id="h3-Gegevensindicatoren842554"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999 Index: De index van vandaag is 0,7, een aanzienlijke stijging ten opzichte van gisteren. Dit duidt erop dat het lange termijn vertrouwen van de markt in Bitcoin is toegenomen.<br>Fear &amp; Greed Index: Momenteel staat deze op 39, wat duidt op een lichte verbetering van het marktsentiment, maar nog steeds in de “angst” zone. Dit betekent dat investeerders voorzichtig blijven over het marktperspectief.</p>
<h3 id="h3-Markt20hotspots130134"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p>Fantom: FTM heeft een 24-uurs stijging van meer dan 20% gezien, waardoor het het best presterende token voor de openbare keten is. Op het nieuwsfront staat FTM op het punt te worden geruild voor het native token S van EVM’s openbare keten Sonic, met een swapverhouding van 1:1. De upgrade van Sonic is het belangrijkste verhaal van <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> en de markt heeft er positief op gereageerd.</p>
<p>Polygon: MATIC 24-uursstijging: bijna 15%, presteert opvallend goed onder de top 20 tokens qua marktkapitalisatie. Als het vroegste mainstream Layer2-conceptproject op de markt, bereikte MATIC een duizendvoudige stijging in de vorige bullmarkt en heeft momenteel een circulatiesnelheid van bijna 100%. MATIC zal op 4 september beginnen met de conversie naar POL-tokens, waardoor POL het primaire gas token wordt voor het Polygon-netwerk.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20gezamenlijk20hoger20waarbij20de20verwachtingen20van20een20renteverlaging20door20de20Federal20Reserve20toenemen379524"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de verwachtingen van een renteverlaging door de Federal Reserve toenemen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de verwachtingen van een renteverlaging door de Federal Reserve toenemen.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk hoger, waarbij de S&amp;P 500-index met 0,42% steeg tot 5.620,85 punten; de Dow Jones Industrial Average steeg met 0,14% tot 40.890,49 punten; de Nasdaq-index steeg met 0,57% tot 17.918,99 punten.</p>
<p>Onder de populaire Amerikaanse aandelen daalde Apple met 0,05%, steeg Nvidia met 0,98%, Microsoft daalde met 0,16%, daalde Google C met 0,79%, daalde Google A met 0,80%, steeg Amazon met 0,69%, steeg Meta met 1,60%, daalde TSMC met 0,36%, steeg Tesla met 0,98%, en steeg AMD met 0,90%.</p>
<p>Uit de notulen van de vergadering van de Federal Reserve bleek dat functionarissen van de Federal Reserve sterk geneigd waren om de rente te verlagen tijdens de beleidsvergadering van september vorige maand, waarbij verschillende functionarissen zelfs bereid waren om de leenkosten onmiddellijk te verlagen. Functionarissen van de Federal Reserve hielden de rente ongewijzigd tijdens de FOMC-vergadering vorige maand, maar openden de deur voor een renteverlaging tijdens de vergadering van 17-18 september. Uit de notulen blijkt dat de “overgrote meerderheid” van de beleidsmakers tijdens de vergadering van juli “van mening was dat een versoepeling van het beleid tijdens de volgende vergadering gepast zou kunnen zijn als de gegevens aan de verwachtingen blijven voldoen.</p>
<p>Ze wezen er ook op dat “veel” functionarissen van de Federal Reserve van mening zijn dat het standpunt over de rentetarieven beperkend is, en “sommige aanwezigen” zijn van mening dat het ongewijzigd houden van de rentetarieven zal betekenen dat het monetaire beleid de economische activiteit zal belemmeren naarmate de inflatiedruk blijft afkoelen.</p>
<p>De notulen van de vergadering toonden ook aan dat hoewel alle functionarissen van de Federal Reserve het erover eens waren om in juli de stabiliteit van de rentevoet te handhaven, “verschillende” beleidsmakers hebben verklaard dat de vooruitgang bij het verminderen van de inflatie in het licht van stijgende werkloosheid “een redelijke reden bood om het doelbereik met 25 basispunten te verlagen tijdens deze vergadering, of zij konden een dergelijke beslissing hebben ondersteund.</p>
<h3 id="h3-Conclusie900191"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>De instroom van gelden in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> is niet goed, en BTC en ETH fluctueren nog steeds binnen een smalle marge. De komende dagen kunnen een kritieke periode voor de markt zijn. Ondanks de trage prestaties van de algehele markt, hebben individuele tokens zoals FTM en MATIC het goed gedaan. De notulen van de Federal Reserve-vergadering die gisteravond zijn vrijgegeven, hebben een aanzienlijke invloed gehad op markttrends, en investeerders moeten de toespraak van Powell op vrijdag nauwlettend in de gaten houden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw posten van het artikel is toegestaan ​​op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>