RGFnZWxpamtzIG5pZXV3cyB8IE1lbWUgQ29pbnMgSE9VU0UgZW4gVFJPTEwgYmVyZWlrZW4gbmlldXdlIGhvb2d0ZXB1bnRlbiwgRWwgU2FsdmFkb3Iga2FuIGRvb3JnYWFuIG1ldCBoZXQgdmVyaG9nZW4gdmFuIEJUQy1iZXppdHRpbmdlbg==

2025-04-30, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/17459850934.28.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20blijft20netto20instroom20behouden20El20Salvador20kan20doorgaan20met20het20kopen20van20BTC822336"><a name="Crypto Dagelijkse Samenvatting: BTC ETF blijft netto instroom behouden, El Salvador kan doorgaan met het kopen van BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF blijft netto instroom behouden, El Salvador kan doorgaan met het kopen van BTC</h2><p>Volgens gegevens van Farside Investors stroomde in totaal $173 miljoen naar de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF gisteren. Onder hen ontving BlackRock IBIT $216 miljoen, en verschillende andere ETF’s zoals ARKB en BTIB hadden kleine uitstroom. Sinds februari dit jaar heeft BTC ETF een unilaterale nettoutflow-trend laten zien, die is omgekeerd sinds vorige week, en het sentiment in de kapitaalmarkt is optimistisch.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF instroom was $18.4 miljoen, waarvan Fidelity FETH instroom was $25.5 miljoen, Grayscale ETHE uitstroom was $7.1 miljoen U, en BlackRock ETHA-gegevens zijn nog niet bijgewerkt.</p>
<p><strong>De uitvoerende order van Trump over de ‘<a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Strategic Reserve’ zal op 5 mei een kritiek punt bereiken</strong></p>
<p>Op 7 maart ondertekende Trump een presidentieel besluit ter bevordering van de oprichting van een strategische Bitcoin-reserve. Het presidentieel besluit vereist een grondige beoordeling van digitale activa in bezit van de federale overheid, waaronder ongeveer 200.000 Bitcoins (ter waarde van ongeveer $17 miljard op het moment van ondertekening).</p>
<p>De order vereist ook dat de minister van Financiën binnen 60 dagen de ‘juridische en investeringsoverwegingen voor het oprichten en beheren van de Strategische <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Reserve en de Reserve van digitale activa van de Verenigde Staten, inclusief de rekeningen waarin de Strategische Bitcoin Reserve en de Reserve van digitale activa van de Verenigde Staten moeten worden aangehouden, en of wetgeving noodzakelijk is om enig aspect van deze order te implementeren of te zorgen voor het passende beheer en de administratie van dergelijke rekeningen’ moet bekijken.</p>
<p>5 mei is de deadline van 60 dagen die is vastgesteld door het uitvoerend bevel van Trump voor de voltooiing van het bovenstaande werk.</p>
<p><strong>Amerikaanse ETF-experts reageren op het uitstel door de SEC van meerdere beslissingen over crypto-ETF-aanvragen: Allemaal zullen ze dit jaar worden goedgekeurd</strong></p>
<p>Volgens een bericht van Nate Geraci, president van The ETF Store, heeft de Amerikaanse Securities and Exchange Commission (SEC) vandaag de goedkeuring van meerdere crypto-ETF-aanvragen uitgesteld. De betrokken producten zijn onder andere: Franklin’s SOL en <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF’s, Grayscale’s HBAR ETF, Bitwise’s DOGE ETF, Franklin en Fidelity <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s stakingoplossingen, Franklin crypto-ETF en het fysieke inschrijvings- en terugkoopmechanisme van Invesco Galaxy Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s.</p>
<p>Nate Geraci zei dat hij nog steeds gelooft dat al deze producten dit jaar zullen worden goedgekeurd.</p>
<p><strong>El Salvador: Blijft doorgaan met <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a> zelfs als het een protocol bereikt met het IMF om te stoppen met het accumuleren van Bitcoin</strong></p>
<p>Volgens Bloomberg zei de Salvadoriaanse minister van Economie Maria Luisa Hayem op het Web Summit-evenement in Rio de Janeiro dat El Salvador Bitcoin zal blijven kopen, ondanks het ondertekenen van een leenprotocol met het Internationaal Monetair Fonds (IMF) dat vereist dat het stop met het accumuleren van Bitcoin. Hayem bevestigde in een live-interview: “President Bukele heeft beloofd door te gaan met het accumuleren van activa.”</p>
<p>Volgens officieel nieuws van The Bitcoin Office of El Salvador heeft El Salvador de afgelopen 7 dagen 8 bitcoins toegevoegd aan zijn nationale strategische bitcoinreserves, waardoor de totale bitcoinreserves zijn gestegen naar 6162.18.</p>
<h2 id="h2-Markttrends20HOUSE20en20TROLL20bereiken20nieuwe20hoogtepunten20ALPACAfuturesmarkt20opnieuw20onder20druk517865"><a name="Markttrends: HOUSE en TROLL bereiken nieuwe hoogtepunten, ALPACA-futuresmarkt opnieuw onder druk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: HOUSE en TROLL bereiken nieuwe hoogtepunten, ALPACA-futuresmarkt opnieuw onder druk</h2><h3 id="h3-Markt20Hotspots657786"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Trump meme coin TRUMP is de afgelopen drie opeenvolgende dagen gedaald. Volgens marktnieuws zou Trump een nieuwe cryptocurrency kunnen lanceren op zijn socialemediaplatform Truth Social. Op dit moment is de stijging van TRUMP-tokens vaak te wijten aan Trump’s eigen propaganda. Het heeft geen andere functionaliteit dan meme-betekenis.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain meme munten HOUSE, TROLL en anderen bereiken nieuwe historische hoogtepunten. Sommige gemeenschappen geloven dat wanneer de markt rustig is, er altijd hoogwaardige tokens op de keten zijn. HOUSE heeft sterke steun gekregen van bekende Engelssprekende KOLs hem en Ansem, en is in de afgelopen week bijna 10 keer gestegen.</p>
<h3 id="h3-Mainstream20Munten817255"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC schommelde gedurende de dag binnen een nauwe marge, en BTC ETF behield nettostromen. Er was op korte termijn geen belangrijk negatief nieuws op de markt. De AHR999-index van vandaag was 0,91, wat aangeeft dat de prijs nog steeds geschikt was voor langetermijnbeleggers om in te investeren.</p>
<p>ETH volgt de marktschommelingen, zonder enige onafhankelijke trend. De ETH/BTC wisselkoers is sinds medio april rond 0,019 gebleven.</p>
<p>Altcoins vielen over het algemeen, AI-agentsectoren trokken zich over het algemeen terug, en de demon coin ALPACA zag opnieuw een short squeeze op de termijnmarkt.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20sloten20hoger20en20de20markt20verwacht20dat20de20Fed20in20juni20zal20beginnen20met20het20verlagen20van20de20rente342770"><a name="Macro Nieuws: Amerikaanse aandelen sloten hoger en de markt verwacht dat de Fed in juni zal beginnen met het verlagen van de rente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen sloten hoger en de markt verwacht dat de Fed in juni zal beginnen met het verlagen van de rente</h2><p>De drie belangrijkste Amerikaanse aandelenindexen sloten hoger, met de S&amp;P 500 die 0,58% hoger eindigde op 5.560,83 punten, de Dow Jones die 0,75% steeg naar 40.527,62 punten, en de Nasdaq die 0,55% steeg naar 17.461,32 punten. Wat betreft Amerikaanse obligaties, bedroeg het referentiepunt van de 10-jarige schatkistrente 4,19%, en het rendement van de 2-jarige schatkist, dat het meest gevoelig is voor het beleidstarief van de Fed, bedroeg 3,65%.</p>
<p>De markt gelooft dat als de tekenen van de Amerikaanse economie die een recessie binnengaat steeds duidelijker worden, de waarschijnlijkheid dat de Federal Reserve een ‘preventieve renteverlaging’ zal nemen ook aanzienlijk zal toenemen. Daarom zijn arbeidsmarktgerelateerde gegevens, zoals het aantal eerste aanvragen voor werkloosheidsuitkeringen en de werkloosheidscijfers, cruciaal voor investeerders om de gezondheid van de Amerikaanse economie te beoordelen. Als beide gegevens op korte termijn aanzienlijk boven verwachting groeien, kan dit aangeven dat de Amerikaanse economie begint te krimpen en dat de Federal Reserve mogelijk een nieuwe reeks renteverlagingen zal starten.</p>
<p>De markt heeft momenteel veel aandacht voor het rapport over de niet-agrarische lonen in april in de VS dat vrijdag zal worden gepubliceerd. Sommige economen hebben gewaarschuwd dat de Amerikaanse arbeidsmarkt ernstige turbulentie kan ervaren als gevolg van de tariefcampagne die is gelanceerd door de regering-Trump, wat de waarschijnlijkheid van de eerste renteverlaging door de Federal Reserve dit jaar in juni aanzienlijk heeft verhoogd.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing 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 beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandig 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><br></div></div></div></div>