RGFnZWxpamtzIE5pZXV3cyB8IFdlZGVyemlqZHNlIFRhcmlldmVuIFJha2VuIFdlcmVsZHdpamRlIFJpc2ljby1BY3RpdmFtYXJrdGVuLCBCVEMgS29tdCBEaWNodGVyIEJpaiBIZXQgT25kZXJzdGUgQmVyZWlr

2025-04-09, 03:59

<p><img src="https://gimg2.gateimg.com/image/article/17441707844.9.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Strategie20kan20BTC20verkopen20Aave20lanceerde20token20inkoopmechanisme313236"><a name="Crypto Dagelijkse Samenvatting: Strategie kan BTC verkopen, Aave lanceerde token inkoopmechanisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Strategie kan BTC verkopen, <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> lanceerde token inkoopmechanisme</h2><p>Volgens gegevens van Farside Investors bedroeg de totale nettostroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s gisteren was $326 miljoen, waarvan BlackRock IBIT een uitstroom had van $253 miljoen, en andere BTC ETF’s hadden voornamelijk kleine nettoutstromen. Gisteren had alleen Fidelity FETH een uitstroom van $3,29 miljoen van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETFs, and other ETH ETFs had no inflows or outflows.</p>
<p>Volgens alternatieve gegevens staat de Fear &amp; Greed Index van crypto vandaag op 18 (gisteren was het 24), en de marktsentiment blijft gefrustreerd en verkeert in een staat van extreme paniek.</p>
<p><strong>Strategie kan gedwongen worden om <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te verkopen om schulden terug te betalen, waarmee het zijn belofte om ‘nooit te verkopen’ breekt</strong></p>
<p>Volgens het 8-K formulier dat door Strategy (voorheen MicroStrategy) is ingediend bij de U.S. Securities and Exchange Commission (SEC) op 7 april, als de prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blijft dalen, kan Strategy gedwongen worden om haar Bitcoin-bezittingen te verkopen om schulden af te lossen, waarmee Michael Saylor’s belofte van ‘nooit Bitcoin verkopen’ wordt verbroken. In haar formulier 8-K verklaarde Strategy: ‘Omdat Bitcoin een aanzienlijk deel van de activa op onze balans uitmaakt, als we niet in staat zijn om op gunstige voorwaarden (of helemaal niet) tijdig eigen vermogen of schuldfinanciering te verkrijgen, kunnen we gedwongen worden om Bitcoin te verkopen om aan onze financiële verplichtingen te voldoen en kunnen we het moeten verkopen tegen minder dan de kostprijs of tegen andere ongunstige prijzen.’</p>
<p>Sinds Trump de verkiezingen heeft gewonnen in november 2024, heeft Strategy 275.965 BTC (25,73 miljard dollar) gekocht tegen een gemiddelde prijs van 93.228 dollar, en dit deel heeft een floating verlies geleden van 4,6 miljard dollar. Volgens de gegevens van StrategyTracker heeft Strategy momenteel 528.185 BTC in bezit, met een gemiddelde kostprijs van 67.458 dollar en een waarde van 40,119 miljard dollar.</p>
<p><strong><a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> lanceerde een token-inkoopmechanisme, waarbij het budget voor de eerste maand een bedrag van $4 miljoen bereikte</strong></p>
<p>Volgens de officiële bestuurspagina van <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> is het voorstel van Aave DAO om de Finance Committee (AFC) te machtigen om $4 miljoen in aEthUSDT te verlenen voor de lancering van de eerste fase van het Aavenomics terugkoop- en distributieprogramma goedgekeurd. Het programma heeft tot doel AAVE terug te kopen van de open markt en te verdelen naar de ecosysteemreserve, waardoor governance-incentives en protocolgezondheid worden verbeterd.</p>
<p>Deze initiële autorisatie zal ondersteuning bieden voor terugkoopoperaties gedurende ongeveer een maand, met inachtneming van buffer-tijd voor de toekomstige implementatie van nieuwe Aave Swapper-contracten. Het volledige programma wordt verwacht voort te zetten met een tempo van maximaal $1 miljoen per week gedurende zes maanden. Het voorstel stelt de AFC in staat om te beginnen met het uitvoeren van de eerste fase van het terugkoopprogramma, waarbij $4 miljoen in aEthUSDT wordt goedgekeurd voor ongeveer een maand aan AAVE-inkopen.</p>
<p><strong>Het effect van wederzijdse tarieven heeft ervoor gezorgd dat de wereldwijde marktkapitalisatie met $10 biljoen is gekrompen</strong></p>
<p>Volgens statistieken van Bloomberg hebben de zogenaamde “wederzijdse tarieven” die door de Verenigde Staten zijn aangekondigd, ernstige gevolgen gehad voor de internationale kapitaalmarkt. Sinds de 3e van deze maand is de marktkapitalisatie van wereldwijde aandelen met $10 biljoen gekrompen, iets meer dan de helft van het BBP van de EU. De Amerikaanse aandelenmarkt zelf heeft zware verliezen geleden, en de marktkapitalisatie van de zeven belangrijkste technologiereuzen op de Amerikaanse aandelenmarkt is in deze periode in totaal met ongeveer $1,65 biljoen verdampt. Daarvan is de productie van Apple sterk afhankelijk van de Amerikaanse overzeese toeleveringsketen. In de afgelopen vier handelsdagen is de aandelenkoers met bijna 23% gedaald.</p>
<p>Beïnvloed door het beleidseffect verspreidde paniek zich in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>. De cryptosector daalde over het algemeen met ongeveer 3% tot 10% in 24 uur. Onder hen zakte ETH ooit onder de $1.400, waarmee het zijn laagste punt sinds maart 2023 bereikte. BTC zakte opnieuw onder de $75.000 mark.</p>
<h2 id="h2-Markttrends20de20marktkapitalisatie20van20RFC20heeft20ooit20meer20dan206020miljoen20bedragen20en20BTC20nadert20het20onderste20bereik207249"><a name="Markttrends: de marktkapitalisatie van RFC heeft ooit meer dan $60 miljoen bedragen, en BTC nadert het onderste bereik" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de marktkapitalisatie van RFC heeft ooit meer dan $60 miljoen bedragen, en BTC nadert het onderste bereik</h2><h3 id="h3-Markt20Hotspots368394"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain meme coin RFC is onlangs enorm gestegen, met een marktkapitalisatie die op een gegeven moment $60 miljoen overschreed. RFC staat voor Retard Finder Coin. Het token werd eind maart uitgegeven op Pumpfun en is tot nu toe meer dan duizend keer gestegen. De officiële Twitter-account van RFC heeft de laatste dagen veel interacties ontvangen van Musk zelf, wat een korte blootstelling aan het RFC-token heeft gebracht. Meme-munten zelf hebben geen waarde, en alleen vertrouwen op de blootstelling gegenereerd door beroemdheden kan geen langetermijnwaardeondersteuning verkrijgen.</p>
<p>Het RWA-concepttoken PLUME presteerde sterk gedurende de dag. Volgens marktnieuws kondigde het vermogensbeheeragentschap Apollo een strategische investering aan in Plume. Deze investering werd gedaan nadat Plume eind vorig jaar een Series A-financiering van $20 miljoen aankondigde. Daarnaast verklaarde medeoprichter van Plume dat het mainnet van het Plume Network gepland staat om dit kwartaal te worden gelanceerd.</p>
<h3 id="h3-Gangbare20Munten802498"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC’s intraday volatility heeft zich geïntensiveerd, met een daling van $81.000 naar ongeveer $75.000, en BTC ETF heeft vier opeenvolgende dagen netto-uitstroom meegemaakt; de AHR999-index van vandaag is 0,63, wat dichter bij het bodemvisgebied van de index komt;</p>
<p>ETH volgde de markt ups en downs, viel onder de $1,400 tijdens de dag, en de ETH/BTC wisselkoers daalde onder 0,019, en bleef een nieuw dieptepunt raken in bijna vier jaar;</p>
<p>Altcoins daalden over het algemeen en de markt ontbrak aan hotspots.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20openden20hoog20en20daalden20Nasdaq20en20SampP2050020belandden20in20een20berenmarkt145101"><a name="Macro Nieuws: Amerikaanse aandelen openden hoog en daalden, Nasdaq en S&amp;P 500 belandden in een berenmarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen openden hoog en daalden, Nasdaq en S&amp;P 500 belandden in een berenmarkt</h2><p>Hoewel de drie belangrijkste Amerikaanse aandelenindices tijdens de sessie met ongeveer 4% stegen, slaagden ze er uiteindelijk niet in om de trend van hoog openen en laag sluiten te doorbreken. Bij het sluiten daalde de Dow Jones Industrial Average met 0,84% tot 37.645,59 punten; de S&amp;P 500 daalde met 1,57% tot 4.982,77 punten en sloot voor het eerst sinds april vorig jaar onder de 5.000 punten; en de Nasdaq Composite daalde 2,15% tot 15.267,91 punten.</p>
<p>Deze week zijn zowel de Nasdaq als de S&amp;P 500 in een berenmarkt terechtgekomen. Op de middellange en lange termijn vraagt Wall Street zich af of dit een eenmalige berenmarkt is of het begin van een cyclische berenmarkt. Analisten van het strategieteam van Goldman Sachs zeiden dat naarmate het risico op economische recessie toeneemt, de verkoop van Amerikaanse aandelen waarschijnlijk zal evolueren naar een meer aanhoudende cyclische berenmarkt. In tegenstelling tot een eenmalige gebeurtenisgedreven schok, weerspiegelt een cyclische berenmarkt veranderingen in de economische cyclus zelf.</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 enkele beleggingsaanbeveling. 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 zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>