RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBibGlqZnQgc2Nob21tZWxlbiwgTEFZRVIgZGFhbGRlIG1lZXIgZGFuIDQ0JSBpbiAyNCB1dXI=

2025-05-07, 03:05

<p><img src="https://gimg2.gateimg.com/image/article/17465869515.7.webp" alt="">
</p><h2 id="h2-Cryptografisch20Dagelijks20Overzicht20New20Hampshire20keurde20<a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>20reserve20wet20goed20Forbes20zei20dat20Wall20Street20zich20voorbereidt20op20een20grote20stijging20in20Bitcoin357149"><a name="Cryptografisch Dagelijks Overzicht: New Hampshire keurde Bitcoin reserve wet goed, Forbes zei dat Wall Street zich voorbereidt op een grote stijging in Bitcoin" class="reference-<a href="" target="_blank" class="blog_inner_link">link</a>"></a><span class="header-link octicon octicon-link"></span>Cryptografisch Dagelijks Overzicht: New Hampshire keurde Bitcoin reserve wet goed, Forbes zei dat Wall Street zich voorbereidt op een grote stijging in Bitcoin</h2><p>Volgens de gegevens van Farside Investors bedraagt de totale uitstroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s gisteren was $122 miljoen. Onder hen had ARKB een uitstroom van $16,1 miljoen en Grayscale GBTC had een nettouitstroom van $89,9 miljoen. Gisteren was de totale uitstroom van ETH ETF’s $17,9 miljoen, waarvan Fidelity FETH een nettouitstroom had van $17,9 miljoen. BlackRock heeft de instroom- en uitstroomgegevens nog niet bijgewerkt.</p>
<p><strong>New Hampshire heeft strategische goedgekeurd bitcoinreserveringsrekening</strong></p>
<p>Cryptojournalist Eleanor Terrett onthulde dat New Hampshire de eerste staat in de VS is die een strategische <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) reserve wet heeft goedgekeurd, waardoor staatspenningmeesters ‘s werelds grootste digitale activum rechtstreeks of via exchange-traded products (ETP’s) kunnen kopen.</p>
<p><strong>Forbes: Wall Street bereidt zich voor op een grote Bitcoin-rally</strong></p>
<p>Volgens Forbes zijn de Bitcoin-prijzen hersteld tot ongeveer $95.000 nadat ze waren gedaald tot een dieptepunt van $75.000 in april. De cryptochef van Gate, David Sacks, verraste handelaren met een zeldzame <a href="/price-prediction/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijsvoorspelling</a>. Nu, terwijl Bitcoin zich haast naar wat BlackRock de ‘geopolitieke fragmentatiesuperkracht’ noemt, blijkt uit een lek dat Wall Street-bedrijven stilletjes wedden op een door Trump aangedreven <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> rally.</p>
<p>Een handelsgroep bij Tower Research Capital heeft ‘kapitaaltoewijzingen aan cryptohandelboeken verhoogd’ en zijn <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>-making infrastructuur, zo wordt gezegd. Wall Street ondersteunt Bitcoin en cryptocurrencies stilzwijgend, nu de regering-Trump van plan is om de handel in Bitcoin en de toegang tot de cryptomarkt te openen, beperkingen uit het Biden-tijdperk te verwijderen, en de wetgeving te versnellen die het financiële systeem zal hervormen.</p>
<p><strong>Mening: De korte termijn opwaartse momentum van Bitcoin kan verzwakken</strong></p>
<p>Een recent analyseverslag gaf aan dat Bitcoin in de afgelopen maand met 25% is gestegen door aanhoudende instroom van ETF-fondsen en institutionele spotaankopen. Echter, enkele opkomende signalen - zoals de daling van de beurspremies en zwakke financieringstarieven - geven aan dat de momentum van deze golf van stijgingen zou kunnen afnemen. Hoewel optiescheefstanden suggereren dat Bitcoin nog steeds enig opwaarts potentieel heeft, bouwen zich macrodrukken op: de Fed blijft neutraal (met een aanstaande vergadering), de volatiliteit neemt langzaam toe, en er blijft onzekerheid over tarieven. De markt vertoont momenteel tekenen van mogelijke consolidatie rond $95.000, waarbij handelaren wachten op nieuwe prikkels.</p>
<h2 id="h2-Markttrends20BTC20blijft20schommelen20LAYER20daalde20meer20dan204420in202420uur630653"><a name="Markttrends: BTC blijft schommelen, LAYER daalde meer dan 44% in 24 uur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC blijft schommelen, LAYER daalde meer dan 44% in 24 uur</h2><h3 id="h3-Markt20Hotspots50815"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>FIDA daalde in korte tijd meer dan 10%. Het nieuws kan worden beïnvloed door het nieuws dat “ <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem domeinnaamservice sns.sol heeft aangekondigd dat het een nieuwe token SNS zal lanceren;</p>
<p>LAYER daalde meer dan 44% in 24 uur. Sterker nog, van 18 februari tot 5 mei schoot LAYER met 460% omhoog en werd daarmee een van de best presterende Altcoins van dit jaar, totdat de plotselinge daling de momentum onderbrak. Zorgwekkend is dat de aankomende grote ontgrendeling op 11 mei de prijs verder omlaag kan duwen als het marktsentiment niet kan herstellen.</p>
<h3 id="h3-Gangbare20Munten803726"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC blijft schommelen, heen en weer springend rond de $95,000 mark, maar gezien de opties skew, heeft Bitcoin nog steeds wat ruimte voor een stijging;</p>
<p>ETH’s potentieel is duidelijk onvoldoende en schommelt rond het $1,800 niveau volgend op de markt;</p>
<p>Altcoins stegen over het algemeen, maar de groei was zwak en de winsten van populaire sectoren zoals AI en RWA waren minder dan 2%.</p>
<h2 id="h2-Macro20Nieuws20Zorgen20over20tarieven20weer20aangewakkerd20Amerikaanse20aandelen20daalden20twee20opeenvolgende20dagen599019"><a name="Macro Nieuws: Zorgen over tarieven weer aangewakkerd, Amerikaanse aandelen daalden twee opeenvolgende dagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Zorgen over tarieven weer aangewakkerd, Amerikaanse aandelen daalden twee opeenvolgende dagen</h2><p>Marktzorgen over tarieven zijn opnieuw aangewakkerd. President Trump en minister van Financiën Bensont hebben toespraken gehouden over handelsprotocollen, die geen duidelijke richting voor de markt boden, en beleggerssentiment is voorzichtig geworden. Amerikaanse aandelen daalden op dinsdag voor de tweede opeenvolgende handelsdag. Bij het sluiten van de dag daalde de Dow Jones Industrial Average met 0,95%; de S&<a href="" target="_blank" class="blog_inner_link">amp</a>;P 500 daalde met 0,77%; en de Nasdaq Composite daalde met 0,87% tot 17.689,66 punten.</p>
<p>De Federal Reserve is dinsdag begonnen met een tweedaagse beleidsvergadering. Verschillende functionarissen hebben eerder gezegd dat ze de vertraagde impact van tarieven op economische gegevens nauwlettend zullen volgen voordat ze beslissen over het beleidstraject. Verschillende functionarissen, waaronder voorzitter Powell, hebben benadrukt dat de Fed ‘geduldig’ zal blijven. De markt verwacht over het algemeen dat de rente op deze vergadering ongewijzigd blijft. Volgens gegevens van de London Stock Exchange Group (LSEG) wedden investeerders momenteel dat de waarschijnlijkheid van een renteverlaging van minstens 25 basispunten bij de vergadering in juli bijna 80% bedraagt.</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 beleggingsadvies. Alle beleggingen brengen inherente risico’s met zich mee; verstandig besluitvorming is essentieel.<br><div></div>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle gevallen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br><p></p><br></em></div></div></div></div>