RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYncyBibGV2ZW4gZ3JvdGUgaW5zdHJvbWVuIGVydmFyZW4sIERPR1Mgc2xhYWdkZSBlciBuaWV0IGluIG9tIGRlIHByZXN0YXRpZXMgdmFuIGFsdGNvaW5zIHRlIHN0aW11bGVyZW4=

2024-08-27, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/172472965627.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20blijven20grote20instromen20ervaren20terwijl20DOGS20prijzen20gemiddeld20presteren654410"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s blijven grote instromen ervaren, terwijl DOGS prijzen gemiddeld presteren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s blijven grote instromen ervaren, terwijl DOGS prijzen gemiddeld presteren</h2><p>Volgens de gegevens van Farside Investor, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gisteren hadden spot ETF’s een netto instroom van $202,6 miljoen, wat resulteerde in netto instromen gedurende 8 opeenvolgende handelsdagen. De totale instroom in de afgelopen 8 handelsdagen bedroeg $753 miljoen, waarbij de belangrijkste instromen bestonden uit een netto instroom van $224,16 miljoen voor BlackRock IBIT en een netto uitstroom van $8,3 miljoen voor Fidelity FBTC.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had een netto uitstroom van $13,2 miljoen, waaronder een netto uitstroom van $2,7 miljoen van Fidelity FETH, $1 miljoen van Franklin EZET en $9,5 miljoen van Grayscale ETHE.</p>
<p><strong>De handelsvolume van DOGS overschrijdt 80 miljoen dollar</strong></p>
<p>Volgens de gegevens van Gate.io heeft de totale handelsvolume sinds de lancering van DOGS op Gate.io $82,37 miljoen bereikt, en de marktkapitalisatie wordt tijdelijk gemeld op $677 miljoen. DOGS is een Telegram-geestmeme-munt, geïnspireerd door de mascotte Spotty, gemaakt door Pavel Durov, de oprichter van TON. Het projectteam heeft op een zonnige manier luchtdroppen uitgevoerd gericht op telegraafgebruikers, met een totale circulatie van 550 miljard stuks. Het iconische beeld van het DOGS-project is een zwart-witte hond genaamd Spotty.</p>
<p><strong>Federal Reserve Daley: Het is tijd voor renteverlagingen</strong></p>
<p>De president van de San Francisco Fed, Daley, zei dat ze van mening is dat het gepast is voor de Fed om te beginnen met het verlagen van de rentetarieven. Daley zei in een interview op maandag: “De arbeidsmarkt heeft een volledig evenwicht bereikt. De tijd is gekomen om het beleid aan te passen.”</p>
<p>Dit standpunt weerspiegelt de opmerkingen van Federal Reserve-voorzitter Powell vorige week, die verklaarde tijdens de Jackson Hole-conferentie dat hij er vertrouwen in heeft dat de inflatie terugkeert naar het pad van 2% en ook verklaarde dat ‘het moment voor beleidsaanpassing is gekomen’. Daley benadrukte dat de Federal Reserve de inflatie moet verlagen naar het streefniveau van 2%, maar zij en haar collega’s zullen ook samenwerken om te voorkomen dat restrictief beleid de arbeidsmarkt schaadt.</p>
<p><strong>In de afgelopen maand is het dagelijkse handelsvolume van het Ethereum-netwerk met ongeveer 55% gedaald in vergelijking met het 7-daagse voortschrijdend gemiddelde
</strong></p>
<p>Volgens gegevens van The Block is het 7-daagse voortschrijdend gemiddelde van het dagelijkse handelsvolume op het Ethereum-netwerk de afgelopen maand met ongeveer 55% gedaald, van $6,56 miljard op 26 juli tot $2,9 miljard vandaag.</p>
<p>Het maandelijkse handelsvolume van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in juli was $134,71 miljard, terwijl het handelsvolume in augustus momenteel slechts $91,46 miljard is, met nog 5 dagen te gaan tot het einde van deze maand.</p>
<p><strong><a href="http://Gate.io" rel="nofollow noopener noreferrer" target="_blank">Gate.io</a> kondigt officiële mouwpartnerschap aan met Inter Milan</strong></p>
<p>Vanaf het 2024⁄25seizoen, <a href="http://Gate.io" rel="nofollow noopener noreferrer" target="_blank">Gate.io</a> zal de officiële mouwpartner worden van Inter Milan, waarbij het logo op de mouwen van de tenues van zowel het heren- als het damesteam te zien zal zijn, naast de U20-teams van de club.</p>
<h2 id="h2-Markttrends20BTC20bevindt20zich20in20een20consolidatiefase20Altcoins20dalen20over20het20algemeen368567"><a name="Markttrends: BTC bevindt zich in een consolidatiefase, Altcoins dalen over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bevindt zich in een consolidatiefase, Altcoins dalen over het algemeen</h2><h3 id="h3-Mainstream20Munten489311"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC onderging een lichte correctie nadat het gisteren doorbrak $64,000, en consolideert momenteel boven $63,000. Er is geen significante instroom van geld in BTC ETFs, en de algehele markt bevindt zich in een consolidatiefase;</p>
<p>ETH schommelt nog steeds rond de $2.700, en de prestaties in deze ronde van het herstel zijn relatief zwak. De verkoopdruk van de Ethereum Foundation heeft de marktsentiment beïnvloed;</p>
<p>De algemene daling van Altcoins en de gemiddelde stijging van DOGS online hebben het marktsentiment niet gestimuleerd.</p>
<h3 id="h3-Gegevensindicatoren964667"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>Vandaag staat de AHR999-index op 0.73, en de huidige prijs is nog steeds geschikt voor langetermijninvesteerders in BTC om te investeren; de Fear &amp; Greed Index staat op 48, wat wijst op een relatief rationeel marktsentiment.</p>
<h3 id="h3-Markt20Hotspots611942"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>DOGS: Het Ton Eco Meme-project DOGS werd gisteren om 20:00 (Peking-tijd) gelanceerd op verschillende handelsplatformen, met een huidige prijs van $0,0013 en een circulerende marktkapitalisatie van ongeveer $600 miljoen. De lancering van DOGS heeft fondsen aangetrokken van andere meme-projecten op Ton Chain, maar NOT is met meer dan 15% gedaald.</p>
<p>In de eerste twee weken van de markt daalden toonaangevende tokens zoals RARE en SUN aanzienlijk. De RARE short squeeze is tijdelijk beëindigd en sommigen geloven dat de fondsen achter RARE mogelijk verband houden met de fondsen die vorig jaar enkele maanden lang TRB exploiteerden. Vanwege de verzending van Justin Sun is de stijging van de markt zwak en is er geen koopvraag, dus een scherpe daling is een onvermijdelijk resultaat.</p>
<h2 id="h2-Macroeconomie20De20Amerikaanse20aandelenmarkt20maakt20een20wisselvallige20periode20door20de20Dow20Jones20Industrial20Average20bereikt20een20nieuw20historisch20hoogtepunt896523"><a name="Macroeconomie: De Amerikaanse aandelenmarkt maakt een wisselvallige periode door, de Dow Jones Industrial Average bereikt een nieuw historisch hoogtepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De Amerikaanse aandelenmarkt maakt een wisselvallige periode door, de Dow Jones Industrial Average bereikt een nieuw historisch hoogtepunt</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt zijn volatiel geweest, waarbij de S&amp;P 500-index met 0,32% daalde naar 5.616,84 punten; De Dow Jones Industrial Average steeg met 0,16% naar 41.240,52 punten; De Nasdaq-index daalde met 0,85% naar 17.725,77 punten.</p>
<p>Onder de populaire Amerikaanse aandelen steeg Apple met 0,15%, daalde Nvidia met 2,25%, daalde Microsoft met 0,79%, steeg Google C met 0,30%, steeg Google A met 0,33%, daalde Amazon met 0,87%, daalde Meta met 1,30%, daalde TSMC met 1,27%, daalde Tesla met 3,23% en daalde AMD met 3,22%.</p>
<p>Voorzitter Powell van de Federal Reserve verklaarde onlangs tijdens de Jackson Hole Global Central Bank Annual Meeting dat het kritieke moment voor renteverlagingen is aangebroken en dat het tijdstip en de snelheid van de verlagingen afhankelijk zullen zijn van de komende economische gegevens, het voortdurend veranderende vooruitzicht en de balans van risico’s. Analyse suggereert dat de belangrijkste redenen waarom de Federal Reserve zich voorbereidt op aanpassing van het monetair beleid, de afname van de inflatiedruk in de Verenigde Staten en de zwakte van de arbeidsmarkt zijn.</p>
<p>Reuters meldde dat zelfs als de Federal Reserve begint met het verlagen van de rente, de hoge leenkosten als gevolg van hoge rentetarieven de ontwikkeling van de Amerikaanse economie nog enige tijd zullen blijven vertragen. Tegelijkertijd brengt de toekomstige koers van het monetair beleid van de Federal Reserve ook grote onzekerheid met zich mee voor de mondiale financiële markt en economische ontwikkeling.</p>
<h3 id="h3-Conclusie535300"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen, de huidige <a href="/price" rel="nofollow noopener noreferrer" target="_blank">Crypto-markt</a> verkeert in een consolidatiefase, waarbij BTC en ETH een relatief stabiele prestatie vertonen, maar Altcoins over het algemeen dalen, wat wijst op een meer rationeel marktsentiment. De macro-economische onzekerheid, met name de verwachting van renteverlagingen door de Federal Reserve, zal van invloed blijven op de markt. Voor langetermijnbeleggers is het huidige prijsniveau nog steeds geschikt voor vaste investeringen, maar er moet aandacht worden besteed aan de kortetermijnrisico’s die worden veroorzaakt door marktfluctuaties. Beleggers moeten op dit moment voorzichtig blijven, de markttrends en macro-economische gegevens nauwlettend volgen, de activa redelijk toewijzen en overmatige speculatie vermijden.</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 visie 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 is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>