RGFnZWxpamtzIG5pZXV3cyB8IEhldCBBbWVyaWthYW5zZSByYXBwb3J0IG92ZXIgZGUgd2Vya2dlbGVnZW5oZWlkIGJ1aXRlbiBkZSBsYW5kYm91dyB6YWwgdmFuYXZvbmQgd29yZGVuIHZyaWpnZWdldmVu

2025-05-02, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17461569845.2.webp" alt="">
</p><h2 id="h2-Crypto20Daily20Digest20Strategy20kan20zijn20bezit20aan20BTC20met20nog20eens202120miljard20verhogen20het20kwartaalwinst20van20Tether20overtrof20120miljard170035"><a name="Crypto Daily Digest: Strategy kan zijn bezit aan BTC met nog eens $21 miljard verhogen, het kwartaalwinst van Tether overtrof $1 miljard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Strategy kan zijn bezit aan BTC met nog eens $21 miljard verhogen, het kwartaalwinst van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> overtrof $1 miljard</h2><p>Volgens gegevens van Farside Investors stroomde in totaal $422 miljoen naar de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF gisteren. Daarvan is BlackRock IBIT met $351 miljoen binnengekomen, Fidelity FBTC met $29,5 miljoen binnengekomen, ARKB met $87 miljoen uitgestroomd, en andere ETF’s hadden voornamelijk kleine instromen. Sinds februari dit jaar heeft BTC ETF een unieke netto uitstroomtrend laten zien, die zich heeft omgekeerd sinds vorige week, en het sentiment op de kapitaalmarkt is optimistisch. Gisteren was het totale handelsvolume van ETH ETF klein, met een totale instroom van $6,5 miljoen.</p>
<p><strong>Strategie voorgesteld om nog eens $21 miljard op te halen <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin kopen</a></strong></p>
<p>Volgens Coindesk heeft Strategy (MSTR) in het eerste kwartaal van 2025 een verlies van $16,49 per aandeel gerapporteerd als gevolg van een scherpe daling in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> prijzen in de eerste drie maanden van dit jaar, wat heeft geleid tot een impairment van $5,9 miljard van zijn <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>-activa. Het bedrijf heeft een nieuw plan aangekondigd voor een openbare marktaandelenaanbieding ter waarde van $21 miljard en heeft zijn BTC-opbrengstdoelstelling verhoogd van 15% naar 25%, en zijn BTC-dollaropbrengstdoelstelling van $10 miljard naar $15 miljard. Vanaf april hield het bedrijf in totaal 553.555 bitcoins aan, met een aankoopprijs van $37,9 miljard en een gemiddelde kostprijs van $68.459 per bitcoin. Strategie zei: ‘Onze kapitaalmarktenstrategie blijft Bitcoin-activa uitbreiden en tegelijkertijd uitstekende waarde leveren aan aandeelhouders.’</p>
<p><strong><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Q1-rapport: het vasthouden van bijna $120 miljard aan Amerikaanse schatkistobligaties, bevestigt een kwartaalwinst van meer dan $1 miljard</strong></p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> International heeft vandaag zijn Q1 2025-rapport uitgebracht, dat is voltooid door BDO, een van ‘s werelds top vijf onafhankelijke accountantskantoren. Het rapport bevestigt de nauwkeurigheid van de financiële gegevens en reserveverslag (FFRR) van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> en biedt een transparante uiteenzetting van de activa die de op fiat gebaseerde stablecoin ondersteunen per 31 maart 2025.</p>
<p>Het rapport vermeldde dat Tether’s totale blootstelling aan Amerikaanse schatkistpapier (inclusief indirecte holdings in geldmarktfondsen en repurchase-overeenkomsten) een recordhoogte bereikte van bijna $120 miljard. Deze mijlpaal bevestigt niet alleen de conservatieve reservebeheerstrategie, maar benadrukt ook de belangrijke rol van Tether als grootschalige distributiehub voor Amerikaanse dollar liquiditeit.</p>
<p>Tether’s traditionele investeringsportefeuille behaalde in het eerste kwartaal een operationele winst van meer dan $1 miljard, voornamelijk door de solide prestaties van zijn Amerikaanse schatkistbezittingen, terwijl de goudinvestering bijna volledig de volatiliteit van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>. Daarnaast is de omloop van USDT in het eerste kwartaal met ongeveer $7 miljard gestegen.</p>
<p><strong>De huidige belangrijkste CEX en DEX financieringspercentages tonen aan dat de markt blijft divergeren, met neutrale en bearish sentimenten die naast elkaar bestaan</strong></p>
<p>Volgens de gegevens van Coinglass tonen de huidige mainstream CEX en DEX financieringspercentages aan dat de markt blijft divergeren, waarbij neutrale en bearish sentimenten naast elkaar bestaan. De specifieke financieringspercentages voor mainstream valuta worden getoond in de bijgevoegde figuur.</p>
<p>Funding rates are the rates set by crypto trading platforms to maintain a balance between the contract price and the price of the underlying asset, and are usually applicable to perpetual contracts. It is a mechanism for exchanging funds between long and short traders. The trading platform does not charge this fee, and it is used to adjust the cost or benefit of traders holding contracts to keep the contract price close to the price of the underlying asset.</p>
<p>Wanneer de financieringsrente 0,01% is, geeft dit de basistarief aan. Wanneer de financieringsrente hoger is dan 0,01%, geeft dit aan dat de markt over het algemeen bullish is. Wanneer de financieringsrente lager is dan 0,005%, geeft dit aan dat de markt over het algemeen bearish is.</p>
<h2 id="h2-Markttrends20de20AIagentsector20steeg20BOOP20bereikte20een20marktkapitalisatie20van2050020miljoen20in20twee20uur666174"><a name="Markttrends: de AI-agentsector steeg, BOOP bereikte een marktkapitalisatie van $500 miljoen in twee uur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de AI-agentsector steeg, BOOP bereikte een marktkapitalisatie van $500 miljoen in twee uur</h2><h3 id="h3-Markt20Hotspots633726"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>AI-agent aandelen zoals AIXBT, AVAAI en AI16Z zijn gestegen. Sinds medio april is de algehele prestatie van de AI-agentensector aanzienlijk sterker dan de markt, waarbij veel tokens meer dan 200% stijgen vanaf hun dieptepunten. AI-agent is nog steeds de meest favoriete sector door marktfondsen;</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain meme coin BOOP werd gisteravond gelanceerd en het marktkapitalisatie bereikte $500 miljoen binnen twee uur. BOOP token is de utility coin van boop.fun, de meme coin launchpad op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, opgericht door NFT blue whale en crypto KOL Dingaling. In tegenstelling tot Pump.fun, zal boop.fun de transactiekosten delen met BOOP-tokenhouders.</p>
<h3 id="h3-Gangbare20Munten512266"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC schommelde omhoog, BTC ETF hervatte grote nettostromen, en het marktsentiment was optimistisch; de AHR999-index van vandaag was 0,95, wat aangeeft dat de prijs nog steeds geschikt is voor langetermijnbeleggers om in te investeren;</p>
<p>ETH volgt de markt ups en downs, zonder enige onafhankelijke trend. De ETH/BTC wisselkoers is rond 0.019 gebleven sinds medio april;</p>
<p>Altcoins stegen over het algemeen, maar de stijging was verspreid, met AI-agents en meme-coins die het goed deden.</p>
<h2 id="h2-Macro20nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20sloten20hoger20en20de20nietagrarische20loonlijsten20worden20vanavond20vrijgegeven873856"><a name="Macro nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten hoger en de niet-agrarische loonlijsten worden vanavond vrijgegeven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: De drie belangrijkste Amerikaanse aandelenindexen sloten hoger en de niet-agrarische loonlijsten worden vanavond vrijgegeven</h2><p>De drie belangrijkste Amerikaanse aandelenindices sloten hoger, met de S&amp;P 500 die met 0,63% steeg tot 5.604,14 punten, de Dow Jones die met 0,21% steeg tot 40.752,96 punten en de Nasdaq die met 1,52% steeg tot 17.710,74 punten. Wat betreft de Amerikaanse obligaties bedroeg het rendement op de benchmark 10-jaars Treasury 4,25% en het rendement op de 2-jaars Treasury, dat het meest gevoelig is voor de beleidsrente van de Fed, bedroeg 3,70%.</p>
<p>Voormalig Amerikaans minister van Financiën Janet Yellen waarschuwde dat de mogelijkheid van een economische recessie in de VS aanzienlijk is toegenomen. Volgens een rapport van 1 mei van de Financial Times, aangehaald door CCTV Nieuws, zei voormalig Amerikaans minister van Financiën Janet Yellen dat het tariefbeleid van de Amerikaanse regering een ‘zeer nadelige’ impact zal hebben op de Verenigde Staten, en zowel Amerikaanse consumenten als bedrijven zullen negatief worden beïnvloed. Als gevolg van het tariefbeleid is de ‘kans op een economische recessie in de Verenigde Staten aanzienlijk toegenomen.’</p>
<p>De laatste belangrijke gegevens van de week, het Amerikaanse werkgelegenheidsrapport buiten de landbouw, zal vanavond om 20:30 worden vrijgegeven en de laatste aanwijzingen geven over de arbeidsmarkt. De markt verwacht over het algemeen dat Fed-voorzitter Powell zijn beleid ongewijzigd zal houden bij de rentevergadering volgende week, aangezien de inflatie boven het streefpercentage van 2% blijft en de maatregelen om de tarieven te verhogen van president Trump hebben tot prijsdruk geleid.</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><div></div>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden 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>