RGFnZWxpamtzIE5pZXV3cyB8IEJpdGNvaW4gS2VlcmRlIHRlcnVnIG5hYXIgJDEwMC4wMDAsIEV0aGVyZXVtIFN0ZWVnIE1lZXIgRGFuIDIwJSBPcCBFZW4gRW5rZWxlIERhZw==

2025-05-09, 03:19

<p><img src="https://gimg2.gateimg.com/image/article/17467597925.9.webp" alt="">
</p><h2 id="h2-Crypto20Daily20Digest20Ripple20en20SEC20hebben20officieel20geschikt20Meta20heeft20voorgesteld20om20opnieuw20het20stabielecoingebied20te20betreden938737"><a name="Crypto Daily Digest: Ripple en SEC hebben officieel geschikt, Meta heeft voorgesteld om opnieuw het stabielecoin-gebied te betreden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Ripple en SEC hebben officieel geschikt, Meta heeft voorgesteld om opnieuw het stabielecoin-gebied te betreden</h2><p>Volgens gegevens van Farside Investors stroomde er in totaal $48 miljoen naar de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s gisteren. Onder hen had Ark ARKB een nettostroom van $13,1 miljoen en Fidelity FBTC had een nettostroom van $35,3 miljoen. Gisteren hadden ETH ETF’s een uitstroom van $16,1 miljoen, waarvan Fidelity FETH een nettostroom van $19,3 miljoen had en Grayscale een nettostroom van $3,2 miljoen had.</p>
<h3 id="h3-Meta20heeft20voorgesteld20om20opnieuw20toe20te20treden20tot20het20stablecoinveld55304"><a name="Meta heeft voorgesteld om opnieuw toe te treden tot het stablecoin-veld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meta heeft voorgesteld om opnieuw toe te treden tot het stablecoin-veld</h3><p>Volgens rapporten voert Meta, drie jaar na het verlaten van het Libra/Diem-project, voorlopige gesprekken met verschillende cryptobedrijven over de toepassing van stablecoins, waarbij ze grensoverschrijdende betalingen aan makers willen verkennen via stablecoins om de kosten te verlagen. Sinds januari dit jaar bekleedt voormalig Plaid-executive Ginger Baker de functie van vicepresident producten bij Meta, waarbij ze de relevante vooruitgang leidt.</p>
<h3 id="h3-Ripple20en20SEC20hebben20officieel20een20schikkingsovereenkomst20bereikt176274"><a name="Ripple en SEC hebben officieel een schikkingsovereenkomst bereikt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripple en SEC hebben officieel een schikkingsovereenkomst bereikt</h3><p>Volgens gerechtelijke documenten hebben Ripple en de U.S. Securities and Exchange Commission (SEC) een schikkingsovereenkomst bereikt om het verbod op Ripple opgelegd door de rechtbank in zijn uitspraak van augustus 2024 op te heffen, en slechts $50 miljoen van de $125 miljoen civiele boete aan de SEC te betalen, waarbij de resterende $75 miljoen aan Ripple wordt teruggegeven.</p>
<p>De twee partijen zijn overeengekomen om niet in beroep te gaan of de intrekking van het eerdere vonnis te verzoeken. De zaak loopt sinds 2020 en heeft betrekking op de verkoop van <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> als een beveiliging. SEC-commissaris Caroline Crenshaw heeft zich publiekelijk uitgesproken tegen de overeenkomst en zei dat deze de regelgevende autoriteit ondermijnt, rechtbankuitspraken ondermijnt en regelgevende lacunes verergert. De overeenkomst heeft nog steeds de goedkeuring van de rechtbank nodig om een “indicatieve uitspraak” te doen en goedkeuring te krijgen van het hof van beroep voordat deze officieel van kracht kan worden.</p>
<h3 id="h3-BTC20versnelde20zijn20transformatie20tot20een20wereldwijde20reserveactiva119481"><a name="BTC versnelde zijn transformatie tot een wereldwijde reserve-activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC versnelde zijn transformatie tot een wereldwijde reserve-activa</h3><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Magazine CEO David Bailey zei in de laatste aflevering van de The Scoop podcast dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zich sneller dan verwacht transformeert tot een wereldwijde reserve-activa. Bailey benadrukte dat naarmate het adoptietempo op nationaal niveau toeneemt, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> geleidelijk is geëvolueerd van een vroeg rebelse technologie tot een strategische overweging op nationaal veiligheidsniveau. Hij wees er met name op dat het versnelde institutionaliseringsproces en de voortdurende investeringen van instellingen zoals Strategy een duidelijk onderscheid creëren tussen Bitcoin en de bredere cryptomarkt.</p>
<h2 id="h2-Markttrends20Bitcoin20keerde20terug20naar2010000020Altcoins20stegen20en20bloeiden38334"><a name="Markttrends: Bitcoin keerde terug naar $100.000, Altcoins stegen en bloeiden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Bitcoin keerde terug naar $100.000, Altcoins stegen en bloeiden</h2><h3 id="h3-Markt20Hotspots767524"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Neiro-tokens zijn in 24 uur meer dan 50% gestegen. Neiro is een meme-munt met een hondenthema. De beroemde mascotte van Dogecoin, Kabosu, is overleden en toen heeft Kabosu’s eigenaar een nieuwe hond mee naar huis genomen. <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> genaamd Neiro. Dit veroorzaakte een frenzy in de meme coin circle, resulterend in de opkomst van veel Neiro-geïnspireerde tokens op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en Ethereum. Net als alle meme-coins heeft Neiro weinig substantiële steun, behalve sentiment.</p>
<p>VIRTUAL’s 24-uurs stijging was 50%. Virtual startte een nieuwe AI Agent rage op Base. Het recente Genesis Launches-evenement op zijn eigen platform werd een katalysator voor de stijging, wat opnieuw marktenthousiasme aanwakkerde.</p>
<h3 id="h3-Gangbare20Munten43555"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC is na een onderbreking van 3 maanden teruggekeerd naar $100.000, voor het eerst sinds begin februari. Momenteel is het marktsentiment hoog en begint het sentiment over de terugkeer van de bullmarkt zich onder investeerders te verspreiden.</p>
<p>ETH steeg in één dag met meer dan 20%, en zijn kracht benaderde de piek in het begin van 2021, en bereikte de $2.200 mark. De intraday <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> dagelijks K-entiteit steeg met 21,8%, en de laatste keer dat dezelfde situatie zich voordeed was op 3 januari 2021.</p>
<p>Altcoins stegen over het algemeen, en gedreven door de bredere markt, bloeiden Altcoins op. VIRTUAL steeg met 50% in 24 uur, EIGEN steeg met 45,7% in 24 uur, en PNUT steeg met 40% in 24 uur.</p>
<h2 id="h2-Macro20nieuws20Markt20sentiment20verbeterde20de20drie20belangrijkste20aandelenindexen20sloten20hoger346683"><a name="Macro nieuws: Markt sentiment verbeterde, de drie belangrijkste aandelenindexen sloten hoger" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Markt sentiment verbeterde, de drie belangrijkste aandelenindexen sloten hoger</h2><p>Op donderdag, Eastern Time, sloten de drie belangrijkste Amerikaanse aandelenindexen hoger af. Bij sluiting steeg de Dow Jones Industrial Average met 0.62%, de S&amp;P 500 steeg met 0.58%, en de Nasdaq steeg met 1.07%. De afronding van het handelsakkoord tussen de VS en het VK en de positieve prestaties van Amerikaanse economische gegevens hebben gezamenlijk de verbetering van het marktsentiment bevorderd.</p>
<p>Trump zei ook dat de Verenigde Staten momenteel in onderhandeling zijn met de Europese Unie over handelskwesties. De Europese Unie zei dat ze bereid is om tarieven op meer dan $100 miljard aan Amerikaanse producten (inclusief auto’s en vliegtuigen) op te leggen als de onderhandelingen mislukken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Orisi T.</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 beleggingsaanbeveling. Aan alle beleggingen zijn inherente risico’s verbonden; verstandig besluitvorming is essentieel.<br><div></div>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle gevallen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br><p></p><br></em></div></div></div></div>