RGFnZWxpamtzIG5pZXV3cyB8IFNPTCB6YWwgZGUgZ3Jvb3RzdGUgb250Z3JlbmRlbGluZyBpbiBkZSBnZXNjaGllZGVuaXMgaW5sdWlkZW4sIHphbCBkZSAkMiBtaWxqYXJkIFNPTCBpbXBhY3QgZGUgbWFya3QgYmXDr252bG9lZGVuPw==

2025-02-25, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/174045569017.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20grootste20ontgrendeling20in20de20geschiedenis20van20SOL20nadert20Strategy20heeft20aangekondigd20dat20het20zijn20bezit20van20BTC20met20nog20eens20220miljard20zal20verhogen965511"><a name="Crypto Dagelijks Overzicht: De grootste ontgrendeling in de geschiedenis van SOL nadert, Strategy heeft aangekondigd dat het zijn bezit van BTC met nog eens $2 miljard zal verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De grootste ontgrendeling in de geschiedenis van SOL nadert, Strategy heeft aangekondigd dat het zijn bezit van BTC met nog eens $2 miljard zal verhogen</h2><p>Volgens gegevens van Farside Investors, de U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $519 miljoen, waarvan Fidelity FBTC een uitstroom had van $247 miljoen en BlackRock IBIT een uitstroom had van $159 miljoen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF had een uitstroom van $79,4 miljoen, waarvan BlackRock ETHA een uitstroom had van $49,5 miljoen, Grayscale ETHE had een uitstroom van $15,4 miljoen, en Bitwise ETHW had een uitstroom van $9,7 miljoen. Sinds 2025 zijn de instromen van BTC en ETH ETF’s elke week vertraagd, en de BTC ETF heeft twee opeenvolgende weken een nettouitstroom van meer dan $500 miljoen gehad, wat wijst op een zwak vooruitzicht op de markt.</p>
<p><strong>De grootste ontgrendeling in SOL geschiedenis nadert, en veel durfkapitalisten hebben miljarden dollars aan niet-gerealiseerde winsten in handen</strong></p>
<p>Volgens Cointelegraph, <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> Maker Wintermute heeft de afgelopen 24 uur $38,2 miljoen aan SOL opgenomen van CEX. Er is nog een week te gaan voordat <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De grootste token-ontgrendeling in de geschiedenis (ter waarde van $2 miljard), met 11,2 miljoen SOL ontgrendeld voor circulatie op 1 maart. SOL-prijzen staan de laatste tijd onder druk en zijn in de afgelopen 24 uur meer dan 15% gedaald tot een bijna drie maanden laag van $140.</p>
<p>Crypto-analist Artchick.eth zei: “Meer dan 15 miljoen SOL (ongeveer $2,5 miljard) zal de komende drie maanden in omloop komen, waarvan het merendeel zal worden gekocht door instellingen zoals Galaxy Digital, Pantera Capital en Figure via FTX-veilingen voor $64 per SOL, en veel durfkapitalisten zullen nog steeds enorme winsten maken.”</p>
<p>Trader RunnerXBT wees erop dat ‘Galaxy Digital, Pantera en Figure ongerealiseerde winsten van respectievelijk $3 miljard, $1 miljard en $150 miljoen aan SOL hebben. De markt speculeert dat deze instellingen hun posities kunnen verkopen, en de recente LIBRA meme coin scam die is goedgekeurd door de Argentijnse president Milley heeft de marktpaniek verergerd.</p>
<p><strong>Bernstein: Liquiditeit zal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> terug van meme naar DeFi, GameFi en NFT, optimistisch over stablecoins en RWA</strong></p>
<p>Crypto-onderzoeksbureau Bernstein heeft een analyserapport uitgebracht waarin staat dat “voorheen de cryptomarkt gedwongen werd zich te wenden tot “nutteloze” meme-munten om hardhandig optreden tegen utility-tokens en NFT-projecten te vermijden, maar naarmate de regering-Trump de regelgeving versoepelt, verwachten analisten dat de liquiditeit zal terugkeren naar nutsbedrijven zoals DeFi (gedecentraliseerde financiën), GameFi en NFT.”</p>
<p>Stablecoins en tokenisatie van activa in de echte wereld (RWA) zijn een andere focus, vooral met de verwachte implementatie van het regelgevingskader voor stablecoins en digitale activa-effecten. Stablecoins zullen eerst van invloed zijn op grensoverschrijdende B2B-betalingen, interbancaire afwikkelingen en overmakingen. Naarmate de regulering van crypto-activa-effecten duidelijker wordt, zal de tokenisatie van eigen vermogen en schulden nieuwe wegen openen voor bedrijfsfinanciering, en de vraag naar stablecoins als afwikkelingsvaluta zal ook toenemen. Het wordt verwacht dat stablecoins de potentiële markt voor handelsplatforms en makelaars zullen uitbreiden - de notering van getokeniseerd eigen vermogen zal de groei van handelsvolumes stimuleren, en de vraag naar stablecoins zal de floatinkomsten van het platform vergroten.</p>
<p><strong>Strategy verhoogde zijn bezit met 20.356 Bitcoins tegen een gemiddelde prijs van $ 97.514</strong></p>
<p>Gisteravond heeft Strategy (voorheen MicroStrategy) zijn bezit van 20.356 bitcoins verhoogd tegen een gemiddelde prijs van $97.514, waarbij ongeveer $2 miljard werd uitgegeven. Eerder zei Strategy-oprichter Michael Saylor in een bericht dat Strategy de uitgifte van $2 miljard aan converteerbare obligaties met een couponrente van 0%, een premie van 35% en een impliciete uitoefenprijs van ongeveer $433,43 had voltooid.</p>
<p>De converteerbare obligaties zijn senior, ongedekte verplichtingen van Strategy. Er wordt geen periodieke rente betaald op de obligaties, en het hoofdbedrag van de obligaties loopt niet op. De obligaties vervallen op 1 maart 2030, tenzij ze eerder worden teruggekocht, ingelost of geconverteerd. Vóór 3 december 2029 hebben houders het recht om hun obligaties alleen om te zetten in aandelen bij het optreden van bepaalde gebeurtenissen. Strategy heeft de intentie om de netto-opbrengst van de aanbieding te gebruiken voor algemene bedrijfsdoeleinden, waaronder de aankoop van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en voor werkkapitaal.</p>
<h2 id="h2-Markttrends20KAITOprijs20presteerde20sterk20SOL20daalde20meer20dan205020vanaf20zijn20historische20hoogtepunt927148"><a name="Markttrends: KAITO-prijs presteerde sterk, SOL daalde meer dan 50% vanaf zijn historische hoogtepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: KAITO-prijs presteerde sterk, SOL daalde meer dan 50% vanaf zijn historische hoogtepunt</h2><h3 id="h3-Markt20Hotspots993342"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Nieuwe munt IP steeg tegen de trend in. Halverwege deze maand steeg IP-tokens bijna 6 keer in 4 dagen, en de marktfondsen werden eruit geperst. IP-tokens zijn de inheemse tokens van de Layer1 blockchain Story Protocol, die worden gebruikt voor on-chain transacties, beveiliging en governance. De huidige circulerende marktkapitalisatie van IP is $1.2 miljard, wat 63e is in de hele markt. Het grootste deel van het handelsvolume van IP is in contracttransacties, wat meer risico loopt om gemanipuleerd te worden door fondsen;</p>
<p>De nieuwe munt KAITO presteerde relatief sterk, bereikte een hoogtepunt van $2 gedurende verschillende opeenvolgende dagen, en bleef stabiel rond $1.65 ondanks een scherpe correctie op de markt. Kaito AI lanceerde drie niveaus van sociale kaarten, en gebruikers moeten een bepaalde hoeveelheid KAITO-tokens inzetten om het overeenkomstige kaartniveau te verkrijgen, wat in zekere zin het kopen van KAITO-tokens stimuleerde.</p>
<h3 id="h3-Mainstream20Munten663200"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC eindigde zijn schok en viel scherp tot onder de $91.000. In de afgelopen twee maanden daalde BTC vele malen naar dit gebied en veerde vervolgens weer op. De AHR 999 index van vandaag is 1.02, wat aangeeft dat BTC momenteel geschikt is voor langetermijnbeleggers om te investeren in vaste termijninvesteringen;</p>
<p>ETH daalde onder de $2.500 grens, als gevolg van de bredere daling van de markt;</p>
<p>Altcoins vielen over het algemeen, SOL daalde onder de $140, meer dan 50% lager dan zijn historische hoogtepunt. De enthousiasme voor meme concepten vervaagt en de markt is een periode van marktherstel ingegaan.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20daalden20over20het20algemeen20en20de20verwachting20is20dat20de20inflatie20hoger20zal20blijven20dan20het20doel20van20de20Fed736213"><a name="Macro Nieuws: Amerikaanse aandelen daalden over het algemeen en de verwachting is dat de inflatie hoger zal blijven dan het doel van de Fed." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen daalden over het algemeen en de verwachting is dat de inflatie hoger zal blijven dan het doel van de Fed.</h2><p>De drie belangrijkste Amerikaanse aandelenindices fluctueerden, waarbij de S&amp;P 500 0,50% daalde tot 5.983,25 punten, de Dow Jones Industrial Average 0,08% steeg tot 43.461,21 punten en de Nasdaq 1,21% daalde tot 19.286,92 punten. Het benchmarkrendement op 10-jaars Treasuries bedroeg 4,40% en het rendement op 2-jaars Treasuries, dat het meest gevoelig is voor de beleidsrente van de Fed, bedroeg 4,13%.</p>
<p>Stifel, een bekende Amerikaanse investeringsbank, waarschuwde dat de Verenigde Staten in 2025 waarschijnlijk de slechtste economische situatie zullen meemaken, en in dit g kan de Amerikaanse aandelenmarkt kelderen. In zijn laatste rapport voorspelde Stifel’s belangrijkste aandelenstrateeg Barry Bannister dat de S&amp;P 500-index eind 2025 op ongeveer 5.500 punten zal sluiten. Dit betekent dat de index met ongeveer 10% zal dalen ten opzichte van het huidige niveau. Bannister zei dat de Amerikaanse economie in de tweede helft van dit jaar waarschijnlijk een periode van milde stagflatie zal ingaan. Het tariefplan van Trump kan prijsverhogingen doorberekenen aan de consument.</p>
<p>Andere Stifel-analisten zeiden in een notitie dat ze verwachten dat de kerninflatie van persoonlijke consumptie-uitgaven, de voorkeursmaatstaf voor inflatie van de Fed, rond 2,75% zal “stagneren” in 2025, boven het streefdoel van de Fed van 2%. Bannister waarschuwde dat hoge inflatie de Fed zou kunnen weerhouden van het verlagen van de rente. Hij verwacht niet dat de Fed dit jaar de rente verder zal verlagen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Glazuur 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; verstandige besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Het opnieuw plaatsen van het artikel is toegestaan, op voorwaarde dat er naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>