RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBsZWlkZGUgZGUgbWFya3QgbmFhciBlZW4gc2lnbmlmaWNhbnRlIG9wbGV2aW5nLCBGVE0gZW4gUEVPUExFIHByZXN0ZWVyZGVuIG9wbWVya2VsaWprIGdvZWQ=

2024-09-10, 04:54

<p><img src="https://gimg2.gateimg.com/image/article/17259439039.10.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BTCdominantie20kan20pieken20BlackRock20IBIT20had20zelden20uitstromen82109"><a name="Crypto Daily Digest: BTC-dominantie kan pieken, BlackRock IBIT had zelden uitstromen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BTC-dominantie kan pieken, BlackRock IBIT had zelden uitstromen</h2><p>Volgens gegevens van Farside Investor was er een kleine instroom van $25 miljoen in de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF gisteren. BlackRock IBIT had een nettostroom van $8,99 miljoen, Fidelity FBTC had een nettostroom van $28 miljoen en Grayscale GBTC had een nettostroom van $22,8 miljoen.</p>
<p>Gisteren was het totale handelsvolume van de Amerikaanse spotmarkt <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De ETF was extreem laag, met een totale uitstroom van $5,2 miljoen. Daarvan was de uitstroom van Grayscale ETHE $22,6 miljoen, en de netto instroom van Fidelity FETH $7,6 miljoen.</p>
<p><strong>Rapport: Als de dominante positie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zijn hoogtepunt bereikt, zullen Altcoins het beter doen dan BTC in de komende maanden</strong></p>
<p>Bitcoin daalde met 10,7% in de eerste week van september en zette daarmee de neerwaartse trend voort sinds eind augustus. Deze daling duwde de prijs echter ook onder het kritieke laagtepunt van $56.711, dat ook op 1 mei verscheen en eerder een snelle opleving had veroorzaakt. Zoals verwacht heeft deze verkoopgolf geleid tot een afname van geheven posities, wat aangeeft dat de markt mogelijk een lokaal dieptepunt nadert. Het is vermeldenswaardig dat sinds 27 augustus de nettostroom van Bitcoin ETF’s $706,1 miljoen heeft bereikt, terwijl het cumulatieve verschil in spot handelsvolume een neerwaartse trend laat zien, wat wijst op een grote hoeveelheid spotverkoop.</p>
<p>Daarentegen heeft de altcoin-markt veerkracht getoond. Tijdens de Bitcoin-verkoop van vorige week was het aandeel van de marktwaarde van Bitcoin (het meten van de relatieve marktwaarde ten opzichte van de rest van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>) daalde met 1,3%. Daarentegen steeg de marktwaarde van andere cryptocurrencies (exclusief de top 10 valuta) met 4,4%. Men kan zeggen dat deze verandering wijst op een mogelijke verschuiving in het marktlandschap, waar investeerders waarde zoeken in altcoins in plaats van nog steeds massaal naar Bitcoin te trekken tijdens een neergang.</p>
<p>Als de dominante positie van Bitcoin inderdaad een lokaal hoogtepunt heeft bereikt, kunnen we zien dat Altcoins het beter doen dan Bitcoin in de komende maanden, wat de basis kan leggen voor een bullmarkt in het vierde kwartaal, mits de macro-economische druk is verminderd.</p>
<p><strong>Harris kondigde een voorgestelde beleidsstandpuntlijst aan, zonder cryptocurrency te noemen</strong></p>
<p>De campagnewebsite van de Amerikaanse vicepresident en Democratische presidentskandidaat Harris heeft een lijst uitgebracht met voorgestelde beleidsposities voor haar toekomstige presidentschap, waaronder belastingverlagingen voor gezinnen uit de middenklasse en het gunstiger maken van huur, maar er wordt niet gerept over crypto-gerelateerde onderwerpen.</p>
<p>In zijn agenda ‘Ondersteuning van Amerikaanse innovatie’ zal Harris zorgen voor de florerende ontwikkeling van de Amerikaanse industrie en werknemers op basis van de vooruitgang die deze regering heeft geboekt. Vicepresident Harris zal de leidende positie van de Verenigde Staten blijven ondersteunen op het gebied van halfgeleiders, schone energie, kunstmatige intelligentie en andere toekomstgerichte industrieën.</p>
<p>Citigroup-strateeg: klantenportefeuille weerspiegelt bearish sentiment op de Amerikaanse aandelenmarkt</p>
<p>Strategen van Citigroup zijn van mening dat de verkoopgolf op de Amerikaanse aandelenmarkt vorige week zou kunnen leiden tot verdere dalingen van de belangrijkste aandelenindices. Strateeg Chris Montagu et al. verklaarden in een rapport aan klanten op maandag dat een groot aantal longposities in de S&amp;P 500-index is geliquideerd, in combinatie met een toename van shortposities in de Nasdaq 100-index, wat wijst op een verschuiving in risicobereidheid naar een meer directe bearishtrend.</p>
<p>Ze verklaarden dat de ont-risico-operaties van hedgefondsen op de S&amp;P 500-index ertoe hebben geleid dat de totale blootstelling slechts de helft bedroeg van het hoogtepunt in het midden van juli. Montagu schreef dat de gedwongen liquidatie van longposities op korte termijn het verkopen kan intensiveren of versnellen, en als deze trend zich voortzet, zullen de nieuw toegevoegde shortposities op vrijdag waarschijnlijk de technologiegerichte indicatoren in netto shortposities drijven.</p>
<h2 id="h2-Markttrends20BTC20leidde20de20markt20naar20een20aanzienlijk20herstel20FTM20presteerde20goed933507"><a name="Markttrends: BTC leidde de markt naar een aanzienlijk herstel, FTM presteerde goed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC leidde de markt naar een aanzienlijk herstel, FTM presteerde goed</h2><h3 id="h3-Gangbare20munten281440"><a name="Gangbare munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare munten</h3><p>BTC is aanzienlijk hersteld, met een piek van $58.000 bereikt, en is nu weer terugglen tot ongeveer $57.000, nog steeds in een volatiele markt;</p>
<p>ETH herstelde samen met BTC, maar de algehele stijging was relatief klein, wat wijst op een relatief zwakke prijsprestatie. Het handelsvolume en de instroom van ETH ETF zijn nog steeds relatief klein;</p>
<p>Altcoins zijn over het algemeen gestegen en Meme blijft de best presterende sector;</p>
<p>Wat betreft de gegevensindicatoren was de AHR999-index vandaag 0,59, met een lichte prijsstijging in samenhang met de index; De Fear &amp; Greed Index is 33, wat wijst op een lichte vermindering van paniek, maar de handelsvolume op de markt blijft traag.</p>
<h3 id="h3-Markt20Hotspots267433"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Openbare keten <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> FTM is in de afgelopen 24 uur de best presterende openbare chain-token geworden, met een stijging van meer dan 15%. FTM heeft drie opeenvolgende dagelijkse winsten behaald. Vanuit het nieuws perspectief is de <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> testnet Sonic gelanceerd en is er momenteel een hoge mate van gemeenschapsdeelname in de testnet interactie. Er zullen echter geen tokens worden uitgedeeld voor de testnet interactie, aldus het officiële Discord kanaal. In augustus van dit jaar kondigde Fantom officieel zijn naamswijziging aan naar Sonic Labs en zal het nieuwe token S aannemen, waarbij FTM S tokens 1:1 uitwisselt.</p>
<p>Memesector: PEOPLE, een concept van de Amerikaanse presidentsverkiezingen, steeg in 24 uur met meer dan 20%, en werd de mainstream Meme-munt met de beste stijging. Morgen, Beijing tijd, zullen de Amerikaanse presidentskandidaten Trump en Harris een televisiedebat hebben, waarbij de markt vooraf wedt dat de twee kandidaten tijdens het debat crypto-gerelateerde beleidsmaatregelen kunnen noemen. De Meme-munten POPCAT en MIGGLES in de kattensector zijn in 24 uur met meer dan 15% gestegen. Momenteel is er geen katten-gerelateerde Meme-munt met een marktwaarde van meer dan $1 miljard, en de sterke prijsprestaties van POPCAT kunnen helpen om de leiding te nemen.</p>
<h2 id="h2-Macroeconomie20de20drie20belangrijkste20indexen20van20de20Amerikaanse20aandelenmarkt20zijn20over20het20algemeen20gestegen20en20activa20zijn20mogelijk20volledig20opgenomen20in20de20verwachting20van20renteverlagingen866714"><a name="Macroeconomie: de drie belangrijkste indexen van de Amerikaanse aandelenmarkt zijn over het algemeen gestegen, en activa zijn mogelijk volledig opgenomen in de verwachting van renteverlagingen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: de drie belangrijkste indexen van de Amerikaanse aandelenmarkt zijn over het algemeen gestegen, en activa zijn mogelijk volledig opgenomen in de verwachting van renteverlagingen.</h2><p>De drie belangrijkste Amerikaanse aandelenindices stegen allemaal met meer dan 1%, waarbij de S&amp;P 500-index steeg met 1,16% tot 5471,05 punten; De Dow Jones Industrial Average steeg met 1,20% tot 40829,59 punten; De Nasdaq-index steeg met 1,16% tot 16884,60 punten.</p>
<p>De benchmark 10-jaars Treasury-rente is 3,70%, terwijl de 2-jaars Treasury-rente, die het meest gevoelig is voor het rentebeleid van de Federal Reserve, 3,68% is.</p>
<p>Onder de populaire Amerikaanse aandelen steeg Apple met 0,04%, Microsoft steeg met 1,00%, Nvidia steeg met 3,54%, Amazon steeg met 2,34%, Google C daalde met 1,70%, Google A daalde met 1,46%, Meta steeg met 0,90%, TSMC steeg met 3,85%, Tesla steeg met 2,63% en AMD steeg met 2,83%.</p>
<p>Vorige week, onder invloed van de laatste belangrijke werkgelegenheidsgegevens vóór de renteverlaging, had de Amerikaanse aandelenmarkt een aanzienlijke terugval, waarbij de werkloosheid daalde en het herstel van nieuwe banen achterbleef bij de verwachtingen. Dit betekent dat de werkgelegenheid inderdaad is vertraagd, maar het is niet genoeg om een recessie te bevestigen. Wat betreft renteverlagingen blijft een renteverlaging van 25BPS in september het referentiescenario. Na de publicatie van de gegevens over de werkgelegenheid buiten de landbouw, raakte de markt betrokken bij een heftig spel van renteverlagingen in september, waarbij de kans op een renteverlaging van 50BPS op een gegeven moment steeg tot 50%, maar uiteindelijk weer terugviel tot 30%. Wanneer een renteverlaging op het punt staat om van kracht te worden, is het belangrijk op te merken dat activa mogelijk al volledig zijn verwerkt in de verwachting van een renteverlaging, en de algehele omvang van de renteverlaging kan ook beperkt zijn.</p>
<h3 id="h3-Conclusie966949"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen is de cryptomarkt de laatste tijd actief geweest, maar er is nog steeds een zeker niveau van volatiliteitsrisico. De trends van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> zullen blijven de algehele sentiment en richting van de markt beïnvloeden. De sterke prestaties van altcoins, met name de Meme-sector, hebben vitaliteit in de markt geïnjecteerd, maar investeerders moeten voorzichtig blijven en hogere prijzen niet blindelings najagen. Data-indicatoren tonen aan dat het marktsentiment is hersteld, maar de angst en hebzucht index staat nog steeds op een laag niveau, en we moeten blijven letten op marktdynamiek en de impact van belangrijke macro-economische gebeurtenissen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Glazuur</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>