RGFnZWxpamtzIG5pZXV3cyB8IE11YmFyYWsga2VsZGVyZGUgbmEgdmVybWVsZGluZywgQlRDIGhhbmRoYWFmZGUgZWVuIHZvbGF0aWVsZSBtYXJrdA==

2025-03-28, 04:03

<p><img src="https://gimg2.gateimg.com/image/article/174313450120.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20is20serieus20ondergewaardeerd20in20vergelijking20met20goud20en20nog20een20Amerikaanse20staat20heeft20Bitcoin20investeringsreserves20goedgekeurd654304"><a name="Crypto Dagelijkse Samenvatting: Bitcoin is serieus ondergewaardeerd in vergelijking met goud, en nog een Amerikaanse staat heeft Bitcoin investeringsreserves goedgekeurd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is serieus ondergewaardeerd in vergelijking met goud, en nog een Amerikaanse staat heeft Bitcoin investeringsreserves goedgekeurd</h2><p>Volgens gegevens van Farside Investors, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had gisteren een totale nettostroom van $85 miljoen, waarvan Fidelity FBTC $97.1 miljoen ontving. De gegevens van BlackRock zijn nog niet bijgewerkt.</p>
<p>Gisteren, het <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF zag een uitstroom van $4.2 miljoen, waarvan Fidelity FETH een uitstroom van $2 miljoen zag. De data van BlackRock is nog niet bijgewerkt.</p>
<p><strong>South Carolina <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Reserve Bill Would Allow 10% of State Funds to be Invested in Bitcoin</strong></p>
<p>De South Carolina Bitcoin Reserve Act (Bill H4256) zou de staatspenningmeester toestaan om 10% van de staatsfondsen te investeren in Bitcoin, met een maximum van 1 miljoen munten.</p>
<p><strong>Aankomend voorzitter van de U.S. SEC: Zal duidelijkere en haalbaardere regelgeving formuleren voor de cryptobranche</strong></p>
<p>Eleanor Terrett, een cryptojournalist, zei op sociale media dat Paul Atkins, de nieuwe voorzitter van de SEC, zei dat hij de harde handhavingsaanpak van de vorige regering zou laten varen: “Branchekennis en gerichte toepassing zijn nodig om ervoor te zorgen dat klanten en investeerders profiteren van efficiënte, effectieve en goed doordachte regelgeving. De missie van onze SEC zou moeten zijn om deze inspanningen te bevorderen en, indien nodig, handhavingsbevoegdheden te gebruiken om opzettelijk gedrag te corrigeren en te herstellen.”</p>
<p>Over digitale activa: “Mijn eerste prioriteit als voorzitter zal zijn om samen te werken met mijn mede-Commissarissen en het Congres om een solide regelgevend kader voor digitale activa te bieden door middel van een redelijke, samenhangende en principiële benadering.”</p>
<p><strong>Opinie: Bitcoin lijkt aanzienlijk ondergewaardeerd te zijn in vergelijking met de goud- en vastgoedmarkten</strong></p>
<p>Analyst PlanB zei: ‘In vergelijking met de goud- en vastgoedmarkten lijkt Bitcoin ernstig ondergewaardeerd te zijn. De marktwaarde van Bitcoin is $2 biljoen, terwijl goud $20 biljoen is. De schaarste van Bitcoin (S2F-ratio) is 120 jaar, terwijl goud 60 jaar is.’</p>
<h2 id="h2-Markttrends20GHIBLIgekte20stimuleerde20mememunt20met20dezelfde20naam20BTC20bleef20schommelen345675"><a name="Markttrends: GHIBLI-gekte stimuleerde mememunt met dezelfde naam, BTC bleef schommelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: GHIBLI-gekte stimuleerde mememunt met dezelfde naam, BTC bleef schommelen</h2><h3 id="h3-Markt20Hotspots522003"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De 24-uurs daling van Mubarak, de leider van BSC, is uitgebreid tot 32%. Sinds de lancering op 13 maart is Mubarak meer dan 50 keer gestegen. Echter, net als alle andere memes, heeft de markt van Mubarak een aanzienlijke correctie gezien, uitsluitend gedreven door de emoties van het oppikken en creëren van memes.</p>
<p>De meme-munt GHIBLI steeg in één dag met meer dan 100%. De naam van de munt komt van de unieke stijl gevormd door animatiemeester Hayao Miyazaki bij het maken van animatiewerken. In de afgelopen tijd hebben beroemdheden, waaronder Elon Musk en Sam Ultraman, foto’s geplaatst met de GHIBLI-stijl op hun sociale media-accounts, wat op zijn beurt een GHIBLI-rage heeft veroorzaakt.</p>
<h3 id="h3-Gangbare20Munten9752"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC handhaafde een volatiele markt. Afgelopen week was de markt positief gestemd vanwege Powell’s dovish speech en tariefverlaging. Vanuit een macro-perspectief is het echter twijfelachtig of dit positieve effect kan blijven voortduren. De tariefstok kan nog steeds op elk moment worden gezwaaid. Zonder sterkere positieve ondersteuning kan BTC nog steeds omslaan naar beneden.</p>
<p>ETH blijft consolideren op $2.000. Er komt op dit moment bijna geen positief nieuws naar buiten. Hoewel de ETF-gegevens zwak zijn, krimpt ook het marktaandeel.</p>
<p>Altcoins daalden over het algemeen, maar sommige sectoren stegen nog steeds tegen de trend in, waarbij de SocialFi-sector de stijging leidde met 6%. Deze sector is een combinatie van Social+Defi+NFT. Andere sectoren waren over het algemeen zwak vanwege het ontbreken van een verhaal.</p>
<h2 id="h2-Macro20Nieuws20Tarief20schaduw20dook20weer20op20drie20belangrijke20Amerikaanse20aandelenindexen20sloten20lager776776"><a name="Macro Nieuws: Tarief schaduw dook weer op, drie belangrijke Amerikaanse aandelenindexen sloten lager" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Tarief schaduw dook weer op, drie belangrijke Amerikaanse aandelenindexen sloten lager</h2><p>Onder de schaduw van tarieven daalden de drie belangrijkste Amerikaanse aandelenindexen donderdag gezamenlijk. De S&amp;P 500 daalde met 0,33%, de Nasdaq Composite met 0,53% en de Dow Jones Industrial Average met 0,37%.</p>
<p>Ondertussen toonde de laatste sentimentenquête van de American Association of Individual Investors, die donderdag werd vrijgegeven, aan dat hoewel de uiterst pessimistische mentaliteit van Amerikaanse aandelenbeleggers deze week verbeterd is, het pessimismeniveau nog steeds hoger is dan 96,8% van de wekelijkse gegevens sinds 1987.</p>
<p>Samir Samana, wereldwijde marktstrateeg bij Wells Fargo Investment Institute, is van mening dat het probleem nu is dat de bijna willekeurige manier waarop de Trump-regering het handelsbeleid implementeert, beleggers ongerust heeft gemaakt, terwijl de benadering van het ‘Ministerie van Regeringsefficiëntie’ ook zorgen heeft gewekt over mogelijke mazen in de wet. Samana zei dat het afhangt van de resultaten van de onderhandelingen over het tarief- en handelskader op korte termijn of de aandelenmarkt weer op koers kan komen.</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 enkel de standpunten van de onderzoeker en vormt geen beleggingsadvies. 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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div>

<p></p><p></p></div><p></p><br></div></div></div><p></p>