RGFnZWxpamtzIG5pZXV3cyB8IERlIGFsdGNvaW5tYXJrdCBpcyB0ZXJ1Z2dldHJva2tlbiwgTGl0ZWNvaW4gaXMgYWwgZWVuIHdlZWsgYWFuIGhldCBzdGlqZ2Vu

2025-02-14, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/173950449910.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20SEC20bevestigde20de20acceptatie20van20DOGE20ETFaanvraag20Litecoin20ETF20kan20de20eerste20nieuwe20crypto20ETF20worden20die20wordt20goedgekeurd41762"><a name="Crypto Dagelijkse Samenvatting: SEC bevestigde de acceptatie van DOGE ETF-aanvraag, Litecoin ETF kan de eerste nieuwe crypto ETF worden die wordt goedgekeurd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: SEC bevestigde de acceptatie van DOGE ETF-aanvraag, <a href="/price/litecoin-ltc" target="_blank" class="blog_inner_link">Litecoin</a> ETF kan de eerste nieuwe crypto ETF worden die wordt goedgekeurd</h2><p>Volgens de gegevens van Farside Investors was gisteren de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had een nettostroom van $183 miljoen, waarvan Grayscale GBTC een nettostroom van $6,9 miljoen had en Fidelity FBTC een nettostroom van $94,5 miljoen had; de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had a netto-instroom van $800.000, waarvan Grayscale ETHE een netto-uitstroom had van $3,8 miljoen en Fidelity FETH een netto-instroom had van $4,6 miljoen.</p>
<p><strong>De Amerikaanse SEC heeft bevestigd dat het de DOGE ETF-aanvraag heeft geaccepteerd</strong></p>
<p>De U.S. Securities and Exchange Commission (SEC) heeft bevestigd dat het de 19b-4 aanvraag die door Grayscale en de New York Stock Exchange is ingediend om een DOGE ETF op te richten, heeft aanvaard.</p>
<p><strong>Mening: <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> moet mogelijk <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> verkopen om te voldoen aan voorgestelde regelgeving voor Amerikaanse stablecoins</strong></p>
<p>Om te voldoen aan voorgestelde Amerikaanse stablecoin-regelgeving, moet <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> mogelijk enkele niet-conforme activa verkopen — waaronder bitcoin, edelmetalen, bedrijfspapier en beveiligde leningen, volgens analisten van JPMorgan.</p>
<p>Er zijn twee stablecoin-wetsvoorstellen ingediend in de Verenigde Staten: het Stablecoin Transparency and Accountability Act (STABLE Act) van het Huis van Afgevaardigden en het United States Stablecoin Innovation Guidance and Establishment Act (GENIUS Act) van de Senaat, die tot doel hebben stablecoin-uitgevers te reguleren via vergunningseisen, risicobeheersregels en 1:1-reserveondersteuning.</p>
<p>Onder de STABLE-wet van het Huis voldoet slechts 66% van de reserves van Tether, terwijl onder de GENIUS-wet van de Senaat de conforme reserveverhouding 83% is.</p>
<p><strong>Bloomberg analist: <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ETF kan de eerste worden <a href="/price/view/new-cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">nieuwe cryptografie</a> ETF goedgekeurd</strong></p>
<p>Op 14 februari reageerde Eric Balchunas, senior ETF-analist bij Bloomberg News, op de vraag over ‘de huidige voortgang van de goedkeuring van belangrijke Altcoin ETF’s’ op sociale media: ‘In honkbaltermen zijn de meesten nog op de eerste honk, behalve <a href="/price/litecoin-ltc" target="_blank" class="blog_inner_link">Litecoin</a> die op weg is naar de derde honk.’</p>
<h2 id="h2-Markttrends20BTC20blijft20schommelen20Litecoin20is20al20een20week20gestegen633056"><a name="Markttrends: BTC blijft schommelen, Litecoin is al een week gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC blijft schommelen, Litecoin is al een week gestegen</h2><h3 id="h3-Markt20Hotspots595629"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Litecoin is al een week op rij gestegen vanwege het nieuws dat de ETF binnenkort zal worden goedgekeurd. Op het moment van schrijven is het gestegen van een dieptepunt van $80 aan het begin van deze maand tot $126.07;</p>
<p>UniLayer-tokens stegen met 2208,24% in 24 uur. Unilayer is een op AMM gebaseerd multi-chain DEX-handelsplatform dat geavanceerde handelstools biedt voor professionele handelaren en ook een Launchpad-functie heeft.</p>
<h3 id="h3-Gangbare20Munten121531"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC blijft schommelen. De Amerikaanse BTC-spot-ETF heeft al vijf opeenvolgende dagen netto-uitstroom gezien en schommelt deze week tussen $94.000 en $98.000;</p>
<p>ETH volgt duidelijk de markttrend, resoneert met de bredere markt, en de activiteit van Amerikaanse ETH spot ETF-fondsen blijft afnemen;</p>
<p>De meeste Altcoin sectoren hebben een lichte correctie ondergaan, maar de PayFi sector steeg tegen de trend in. Het top project <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> steeg met 3,38% in 24 uur, Litecoin (LTC) steeg met 2,54%, en <a href="/price/telcoin-tel" rel="nofollow noopener noreferrer" target="_blank">Telcoin</a>(TEL) steeg met 13.22%.</p>
<h2 id="h2-Macro20nieuws20het20sentiment20op20de20Amerikaanse20aandelenmarkt20is20duidelijk20opgewarmd20en20de20PCEgegevens20zijn20matig20gestegen665357"><a name="Macro nieuws: het sentiment op de Amerikaanse aandelenmarkt is duidelijk opgewarmd en de PCE-gegevens zijn matig gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: het sentiment op de Amerikaanse aandelenmarkt is duidelijk opgewarmd en de PCE-gegevens zijn matig gestegen</h2><p>Het sentiment van de Amerikaanse aandelenmarkt is duidelijk verbeterd en de drie belangrijkste indexen sloten hoger, met de S&amp;P 500 met 1% en de Nasdaq met 1,5% omhoog. Bij het sluiten steeg de Dow Jones Industrial Average met 0,77% tot 44.711,43 punten; de S&amp;P 500 steeg met 1,04% tot 6.115,07 punten; en de Nasdaq steeg met 1,50% tot 19.945,64 punten.</p>
<p>De Amerikaanse president Donald Trump heeft donderdag een presidentieel memorandum ondertekend waarin hij wederkerige tarieven voorstelt, maar heeft ze niet onmiddellijk ingevoerd, waardoor sommige investeerders zich wat geruster voelen. De door de VS genomineerde minister van Handel, Lutnick, voorspelde dat de nieuwe tarieven op 2 april zouden worden ingevoerd.</p>
<p>Gegevens die voor de opening van de markt op donderdag zijn vrijgegeven, toonden aan dat de Amerikaanse producentenprijsindex met 0,4% op maandbasis steeg in januari, hoger dan de marktverwachtingen van 0,3%; de kern-PPI exclusief voedsel en energie steeg met 0,3%, in lijn met de verwachtingen. Hoewel de meest recente PPI-cijfers over het algemeen nog steeds hoog waren, waren de winsten in categorieën die verband houden met de PCE-gegevens bescheidener. De PCE-prijsindex is een nauwlettend gevolgde inflatiemaatstaf door de Federal Reserve.</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. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<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 schending van het auteursrecht.<br></div>

<p></p><p></p><div class="blog-details-info"><br>  <div>Auteur:<strong>Orisi T.</strong>Gate.io onderzoeker<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen beleggingsadvies. Beleggen brengt risico's met zich mee, dus beslissingen dienen zorgvuldig te worden overwogen.<br>  </em><div><em></em>This content is original, copyright is owned by Gate.io, if you need to reprint, please indicate the author and source, otherwise legal responsibilities will be pursued.<br></div><p></p><br></div></div></div></div></div></div></div><p></p>