RGFnZWxpamtzIE5pZXV3cyB8IFhSUCBiZXJlaWt0IHNjaGlra2luZyBtZXQgQW1lcmlrYWFuc2UgcmVjaHRiYW5rLCBTT0wvRVRIIGhhbmRlbHNwYWFyIGJsaWpmdCBoaXN0b3Jpc2NoZSBob29ndGUgYmVyZWlrZW4=

2024-08-08, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/17230901858.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20XRP20stijgt20met202020na20het20bereiken20van20een20schikking20met20de20Amerikaanse20rechtbank20de20Federal20Reserve20kan20de20rente20in20september20met205020basispunten20verlagen306916"><a name="Crypto Daily Digest: XRP stijgt met 20% na het bereiken van een schikking met de Amerikaanse rechtbank, de Federal Reserve kan de rente in september met 50 basispunten verlagen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> stijgt met 20% na het bereiken van een schikking met de Amerikaanse rechtbank, de Federal Reserve kan de rente in september met 50 basispunten verlagen.</h2><p>Volgens Farside Investor-gegevens is er over het algemeen een nettostroom van kapitaal uitgegaan. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF’s was gisteren $45 miljoen. Na twee opeenvolgende dagen zonder instroom of uitstroom, zag BlackRock IBTC gisteren een instroom van $53 miljoen op één dag.</p>
<p>Het totale nettokapitaaluitstroom van ETH ETF bedroeg $23,7 miljoen en de uitstroom van Grayscale ETHE bedroeg $31,9 miljoen, een daling van 90% in vergelijking met de uitstroom in de beginfase van de ETF-lancering.</p>
<p><strong>Ripple bereikt schikking met Amerikaanse rechtbank, beboet met $125 miljoen</strong></p>
<p>Rechter Anastasia Torres van het zuidelijke district van New York oordeelde dat de verkoop van Ripple <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> aan particuliere beleggers via een handelsplatform heeft geen federale effectenwetten overtreden. Ripple’s 1.278 institutionele verkooptransacties hebben echter effectenwetten overtreden, resulterend in een boete van $12.503,5 miljoen, ver onder de eis van de SEC van $1 miljard voor illegale winsten en vooroordeelrente, evenals een civiele boete van $900 miljoen. Dit is ongetwijfeld een aanzienlijk voordeel voor XRP.</p>
<p>Volgens de marktinformatie van Gate.io steeg XRP vanochtend boven de $0.6, met een huidige prijs van $0.601, en bereikte een hoogtepunt van $0.6434, met een stijging van 19.7% in 24 uur.</p>
<p><strong>Analyse: De verkoopdruk van PlusToken is veel minder dan 789.000, aangezien de meeste al zijn verkocht</strong></p>
<p>On-chain data-analist Yu Jin verklaarde in een bericht dat de 789.534 ETH verkocht door PlusToken, waarvan het grootste deel tussen juni en september 2021 via meerdere adressen op een gecentraliseerd handelsplatform terechtkwam (het platform ging failliet voor het einde van 2021). Ten minste 268.843 daarvan werden destijds op de beurs gestort.</p>
<p>Bovendien hebben 12 adressen die in de afgelopen 30 uur PlusToken-gerelateerde ETH hebben verzameld een totaal van 25.757 ETH verzameld (ongeveer $63,1 miljoen). Dus er zal niet zo’n enorm bedrag van 789.534 ETH te koop zijn, waarvan het grootste deel in 2021 verkocht had moeten zijn, en de huidige verzameling is een klein deel dat niet in 2021 is verkocht.</p>
<p>De vorige tweet over ‘PlusToken-adressen die 789.534 ETH verzamelen’ van Lookonchain is verwijderd.</p>
<p><strong>Voormalig voorzitter van de New Yorkse Fed Dudley: de Fed moet snel handelen, de vergadering in september kan de rente met 50 basispunten verlagen</strong></p>
<p>Volgens een rapport van Caixin zei voormalig voorzitter van de New York Fed, Dudley, dat hij twee weken geleden zelf veranderde van een havik naar een duif en het ondersteunen van verdere renteverhogingen door de Fed opgaf en in plaats daarvan pleitte voor een onmiddellijke renteverlaging om een economische recessie te voorkomen. In de afgelopen twee weken zijn er meer bewijzen dat de Amerikaanse arbeidsmarkt naar zwakte neigt, terwijl de inflatie verder afneemt. Hoe langer de Federal Reserve wacht, hoe groter de potentiële schade kan zijn. Het wordt verwacht dat de Federal Reserve de rente met 25 of 50 basispunten kan verlagen tijdens de vergadering in september.</p>
<h2 id="h2-Markttrends533036"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is nog steeds aan het herstellen op een hoog zijwaarts niveau, waarbij $57.500 een belangrijk drukniveau is op de vier-uurs grafiek. Hoewel de lancering van Bitcoin spot ETF’s een golf van marktenthousiasme heeft veroorzaakt, is de handelsvolume aanzienlijk afgenomen. Vooral voor BlackRock’s IBTC is er al meerdere opeenvolgende dagen geen instroom van fondsen geweest, wat erop wijst dat de oorspronkelijke interesse van de markt in spot ETF’s mogelijk afneemt.</p>
<p>ETH: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De prestaties zijn relatief zwak, met ETH/BTC handelsparen die een driejarig dieptepunt bereiken. Ondanks de lancering van spot ETFs, bleven hun prestaties achter bij de verwachtingen, in combinatie met de verkoopdruk van historische legacy-aandelen, wat leidde tot druk op de Ethereum-prijzen. In vergelijking met Bitcoin lijkt de prestatie van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in deze opleving zelfs zwakker.</p>
<p>Altcoins: De Altcoin-markt is over het algemeen gedaald, maar de prestaties van SOL blijven sterk. De sterke prestaties van SOL hebben het tot de best presterende mainstream Altcoin in deze marktronde gemaakt, waardoor de uitstekende prestaties van het geheel worden gestimuleerd. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem.</p>
<h3 id="h3-Gegevensindicatoren852884"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999-index: De AHR999-index van vandaag is 0.59, steeds dichter bij een bodemvisindex. Dit geeft aan dat de huidige prijs een goed moment is om in batches te kopen, en investeerders kunnen overwegen om geleidelijk posities op te bouwen.</p>
<p>Fear &amp; Greed Index: De huidige Fear Greed Index is 20, wat aangeeft dat het marktsentiment zich in een staat van extreme paniek bevindt. Naar verwachting zal dit trage marktsentiment blijven aanhouden.</p>
<h3 id="h3-Markt20Hotspots157497"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Solana-ecosysteem: <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL) blijft stijgen boven $150, en de wisselkoers met Ethereum (ETH) blijft historische hoogtepunten bereiken. Solana-ecosysteemprojecten zoals WIF, BOME, POPCAT, enz. hebben allemaal aanzienlijke stijgingen gezien. SOL presteerde het beste in deze marktomwenteling, waardoor er sterke prestaties werden geleverd voor het gehele Solana-ecosysteem en aanzienlijk beter presteerde dan andere publieke blockchains.</p>
<p>Goed gevestigd betalingsproject XRP: XRP steeg met 20% binnen de dag, voornamelijk als gevolg van een schikking met een Amerikaanse rechtbank en het betalen van een boete van $125 miljoen. In de geschiedenis heeft XRP goede opwaartse prestaties laten zien in elke crypto bullmarkt. Het langetermijneffect van de schikking met de Amerikaanse rechtbank op de XRP-prijzen moet nog blijken, maar op korte termijn stimuleert dit positieve nieuws ongetwijfeld het marktvertrouwen.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20gezamenlijk20lager20terwijl20de20Amerikaanse20obligatierendementen20stegen373207"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, terwijl de Amerikaanse obligatierendementen stegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, terwijl de Amerikaanse obligatierendementen stegen</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten collectief lager af, waarbij de S&amp;P 500-index met 0.77% daalde tot 5199.50 punten; De Dow Jones Industrial Average daalde met 0.60% tot 38763.45 punten; De Nasdaq-index daalde met 1.05% tot 16195.81 punten. Het referentiepunt van de 10-jaars Treasury-opbrengst is 3.96%, terwijl de opbrengst van de 2-jaars Treasury, die het meest gevoelig is voor de beleidsrente van de Federal Reserve, 4.00% is.</p>
<p>Onder de populaire Amerikaanse aandelen steeg Apple met 1,25%, Microsoft daalde met 0,30%, Nvidia daalde met 5,08%, Google C steeg met 0,13%, Google A steeg met 0,41%, Amazon steeg met 0,52%, Meta daalde met 1,05%, TSMC daalde met 0,23%, Tesla daalde met 4,43%, en AMD daalde met 1,16%.</p>
<p>S&amp;P Global verwacht dat de Federal Reserve in september de rente met 25 basispunten zal verlagen, waarmee een nieuwe versoepelingscyclus wordt ingeluid. Dit jaar zal er een cumulatieve renteverlaging van 50 basispunten zijn, en volgend jaar zal er nog een renteverlaging van 100 basispunten zijn. Het risico van renteverlagingen lijkt eerder te komen dan later. De basale visie van S&amp;P is dat de Federal Reserve gestaag en intermitterend een reeks renteverlagingen zal doorvoeren, wat de Fed zal helpen een zachte landing te realiseren. S&amp;P gelooft dat de afkoeling van de arbeidsmarkt in combinatie met vooruitgang in de inflatie voldoende is om de Federal Reserve aan te zetten tot het beginnen van een versoepeling van haar restrictieve monetair beleid. Ondertussen schreef S&amp;P de vertraging op de arbeidsmarkt toe aan normalisatie, eerder dan aan een aanstaande economische recessie.</p>
<h3 id="h3-Conclusie887957"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen is er een zeker verschil in prestaties tussen Bitcoin en Ethereum, waarbij Bitcoin zijwaarts handelt op hoge niveaus en Ethereum zwakte vertoont. Hoewel de Altcoin-markt over het algemeen is gedaald, heeft het Solana-ecosysteemproject sterke prestaties getoond en is het een belangrijk hoogtepunt op de markt geworden. Gegevensindicatoren tonen aan dat de huidige markt dicht bij de ondergrens ligt, maar het marktsentiment blijft laag en investeerders moeten voorzichtig opereren.</p>
<p>In de komende dagen moeten we letten op of Bitcoin het drukniveau van $57.500 kan doorbreken en of Ethereum het verkoopdrukprobleem kan oplossen en stabiliseren. Ondertussen zal de prestatie van het Solana-ecosysteem en XRP blijven zorgen voor markthotspots, wat de moeite waard is om op te letten.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijsing</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 beleggingsadvies.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>