RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYncyB6YWdlbiBhYW56aWVubGlqa2UgdWl0c3Ryb29tLCBET0dTIHRvb25kZW4gZGUgc3RlcmtzdGUgcHJlc3RhdGllIGluIGRlIG1hcmt0ZGFsaW5n

2024-08-28, 05:31

<p><img src="https://gimg2.gateimg.com/image/article/172482293028.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20zagen20aanzienlijke20uitstroom20Maker20lanceerde20governancetoken20SKY368499"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s zagen aanzienlijke uitstroom, Maker lanceerde governance-token SKY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s zagen aanzienlijke uitstroom, Maker lanceerde governance-token SKY</h2><p>Volgens gegevens van Farside Investor was er een netto-uitstroom van $127,05 miljoen uit de Amerikaanse spotmarkt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hadden gisteren een einde gemaakt aan de vorige acht opeenvolgende handelsdagen van nettostromen. Gisteren had ARKB een nettostroom van $102 miljoen, had GBTC een nettostroom van $18,3 miljoen en had BITB een nettostroom van $6,8 miljoen.</p>
<p>Gisteren was er een netto uitstroom van $3,44 miljoen uit de Amerikaanse spotmarkt <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s, zonder instroom/uitstroom van BlackRock ETHA, een netto uitstroom van $9,18 miljoen van Grayscale ETHE, en een netto instroom van $3,88 miljoen van Fidelity FETH. Bitwise ETHW had een netto instroom van $1,86 miljoen.</p>
<p><strong>Analist: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> kan tegen het einde van 2024 $150.000 bereiken</strong></p>
<p>Jamie Coutts, Chief Crypto Analyst bij Real Vision, verklaarde dat “tenzij er een fundamentele verandering is”, de prijstrend van Bitcoin naar verwachting nog steeds een “gek seizoen” zal ingaan, ook wel bekend als de “bananenzone”. Deze term werd bedacht door Real Vision-oprichter Raoul Pal om te verwijzen naar een schuldherfinancieringscyclus die wordt aangedreven door macro-economische krachten die van invloed zijn op alle activaprijzen, maar de prestaties van crypto zijn bijzonder uitstekend.</p>
<p>Coutts wees erop dat in de eerste twee bullmarkt cycli, Bitcoin binnen 365 dagen na de piek van de lokale Amerikaanse dollarkoers nieuwe historische hoogtepunten bereikte. Hij suggereerde dat als Bitcoin het vorige bullmarkt patroon volgt, de prijs meer dan 100% kan stijgen vanaf het huidige niveau en tegen het einde van 2024 $150.000 kan bereiken.</p>
<p><strong>CoinGecko-rapport: PolitiFi-sector token presteert dit jaar beter dan Meme coin</strong></p>
<p>Cryptocurrency-gegevensaggregatieplatform CoinGecko heeft een rapport uitgebracht waarin staat dat van 1 januari tot 25 augustus 2024 de PolitiFi (Meme gerelateerd aan Amerikaanse verkiezingsfiguren) token categorie met 782.4% is gestegen, wat beter presteert dan de brede Meme coin categorie, die in dezelfde periode met 90.2% is gestegen.</p>
<p>Hoewel PolitiFi-tokens beter hebben gepresteerd dan Meme-tokens, lopen ze nog steeds ver achter op de laatste. Op 25 augustus heeft de PolitiFi-sector een marktaandeel van 1,5% in de categorie Meme-munten, met een marktwaarde van $ 680,8 miljoen, terwijl de marktwaarde van Meme-munten $ 45,6 miljard is.</p>
<p><strong>Maker-merk is opnieuw gelabeld als Sky Protocol en zal de inheemse governance-token SKY lanceren</strong></p>
<p>Op 27 augustus heeft de Maker-protocol officieel zijn naam veranderd in Sky en de namen van zijn geüpgradede stabiele munt en inheemse governance-token aangekondigd, met als doel gedecentraliseerde financiering (DeFi) toegankelijker te maken voor het publiek. Als onderdeel van de naamswijziging heeft Maker de grootste gedecentraliseerde stabiele munt ter wereld, Dai (DAI), omgedoopt tot USDS.</p>
<p>Het protocol introduceert ook de Sky (SKY) native governance token voor een bredere Sky-ecosysteem, als een geüpgradede versie van de Maker (MKR) token. Rune Christensen, medeoprichter van MakerDAO, verklaarde dat deze naamsverandering een stap is naar het verwelkomen van de ‘volgende evolutie van DeFi’. MKR-houders kunnen hun MKR upgraden naar SKY en SKY kan ook worden teruggezet naar MKR. Upgraden is optioneel. Gebruikers kunnen tijdens het upgradeproces 24.000 SKY’s inwisselen voor elke MKR.</p>
<h2 id="h2-Markttrends20De20markt20is20gekelderd20en20er20zijn20geen20hotspots20voor20Altcoins453215"><a name="Markttrends: De markt is gekelderd en er zijn geen hotspots voor Altcoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt is gekelderd en er zijn geen hotspots voor Altcoins</h2><h3 id="h3-Mainstream20Munten780606"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC daalde gisteren scherp tot ongeveer $58.000, en na twee opeenvolgende dagen van instroom van meer dan $200 miljoen, ondervond BTC ETF gisteren een grote uitstroom. Er is geen andere verklaring voor de markttrend, en over het algemeen loopt de markt voor op het nieuws;</p>
<p>ETH’s prestaties blijft zwak, waarbij het op een gegeven moment onder de $2,400 zakt. De handelsvolume van ETH ETF is zwak en er is sinds de lancering weinig positieve kapitaalinstroom geweest;</p>
<p>Altcoins zijn over het algemeen scherp gedaald en de markt is stil.</p>
<h3 id="h3-Gegevensindicatoren163164"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>De AHR999-index is vandaag 0.65 en de huidige prijs is nog steeds geschikt voor BTC langetermijnbeleggers om te investeren. De Fear &amp; Greed Index staat op 30, wat aangeeft dat het marktsentiment is teruggekeerd naar het stadium van angst. Dit betekent meestal dat er mogelijk wat koopkansen op de bodem van de markt zijn, maar er moet ook voorzichtigheid worden betracht.</p>
<h3 id="h3-Markt20Hotspots851280"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Ton Eco: TON blijft dalen en het nieuws van de arrestatie van Durov blijft nog gisten. Veel beroemdheden, waaronder Musk, hebben opgeroepen tot de redding van Durov en er zijn veel Durov-concepttokens op de markt verschenen, maar ze hebben allemaal slecht gepresteerd. Na de lancering van DOGS bleef de prijs rond de $0,00125 liggen. Ondanks de algehele marktdownturn bleef de prijs stabiel en de huidige circulerende marktkapitalisatie van DOGS bedraagt ongeveer $650 miljoen. Dit toont de relatieve stabiliteit van DOGS in de huidige marktomgeving aan, wat de aandacht van investeerders waard is.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindices20stijgen20lichtjes20terwijl20de20Amerikaanse20obligatierendementen20blijven20dalen480014"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices stijgen lichtjes, terwijl de Amerikaanse obligatierendementen blijven dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices stijgen lichtjes, terwijl de Amerikaanse obligatierendementen blijven dalen</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk hoger af, waarbij de S&amp;P 500-index met 0,16% steeg tot 5.625,80 punten; De Dow Jones Industrial Average steeg met 0,02% tot 41.250,50 punten; De Nasdaq-index steeg met 0,16% tot 17.754,82 punten. Daarnaast is het rendement van de 10-jaars staatsobligatie 3,83% en het rendement van de 2-jaars staatsobligatie, die het meest gevoelig is voor het rentetarief van de Fed, is 3,83%.</p>
<p>Na de sterkste oproep van voorzitter van de Federal Reserve, Powell, om de rente te verlagen, lijkt het erop dat de renteverlaging al in beton gegoten is. Volgens CME’s “FedWatch” is de waarschijnlijkheid dat de Federal Reserve de rente in september met 25 basispunten verlaagt 66%, en de waarschijnlijkheid van een renteverlaging met 50 basispunten is 34%.</p>
<h3 id="h3-Conclusie941355"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>De huidige markt toont een duidelijk gevoel van angst, waarbij de prijzen van grote cryptocurrencies en Altcoins over het algemeen dalen. Individuele activa zoals BTC en DOGS vertonen echter een zekere mate van weerstand tegen daling onder specifieke omstandigheden, wat de moeite waard is om op te focussen voor langetermijnbeleggers. Veranderingen in de macro-economische omgeving, zoals mogelijke renteverlagingen door de Federal Reserve, kunnen ook nieuwe kansen bieden aan de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a>.</p>
<p>Investeerders moeten voorzichtig blijven in de huidige marktomgeving, marktsentiment en macro-economische dynamiek monitoren en hun beleggingsstrategieën op tijd aanpassen. Voor langetermijnbeleggers kunnen de huidige prijsniveaus en marktsentiment enige beleggingsmogelijkheden bieden, maar er moet nog steeds voorzichtigheid worden betracht om overmatige risico-expositie te 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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>