RGFnZWxpamtzIG5pZXV3cyB8IEtBSVRPIFJvc2UgQWdhaW5zdCB0aGUgVHJlbmQgZW4gUmFha3RlIGVlbiBOaWV1dyBSZWNvcmRob29ndGUsIEFMQ0ggTGVpZGRlIGhldCBBSSBBZ2VudGVuc3Bvb3IgbmFhciBBbGdlbWVuZSBIZXJzdGVs

<p><img src="https://gimg2.gateimg.com/image/article/174062981319.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20heeft20gedurende20720opeenvolgende20dagen20nettostromen20ervaren20en20de20neerwaartse20trend20van20de20markt20is20niet20omgekeerd766599"><a name="Crypto Dagelijkse Samenvatting: BTC ETF heeft gedurende 7 opeenvolgende dagen nettostromen ervaren en de neerwaartse trend van de markt is niet omgekeerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF heeft gedurende 7 opeenvolgende dagen nettostromen ervaren en de neerwaartse trend van de markt is niet omgekeerd</h2><p>Volgens de gegevens van Farside Investors, de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $756 miljoen, wat zeven opeenvolgende dagen van nettostromen markeert; onder hen had BlackRock een uitstroom van $420 miljoen, wat ook de grootste enkelvoudige uitstroom was sinds de lancering van BlackRock IBIT. Daarnaast had Fidelity FBTC een uitstroom van $145 miljoen en had Ark ARKB een uitstroom van $60,5 miljoen.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF zag een uitstroom van $24.5 miljoen, waarvan Fidelity FETH een uitstroom van $18.4 miljoen zag. De gegevens van BlackRock ETHA zijn nog niet bijgewerkt.</p>
<p><strong> Analyse: Optiegegevens tonen aan dat de BTC-trend mogelijk niet is omgekeerd en dat de volatiliteit van ETH naar verwachting laag zal zijn in de nabije toekomst</strong></p>
<p>Adam, een analist bij het bekende optiehandelsplatform Greeks.live, plaatste op sociale media dat er een algemeen bearish sentiment op de markt is, en gelooft dat de opleving zwak is en BTC mogelijk verder zal dalen tot onder de $80.000. Sommigen geloven zelfs dat het vorig jaar’s volatiele trend zal ‘reproduceren’. Veel handelaren wezen erop dat de huidige prijs onder de ‘M-top’ is glen en dat er risico’s zijn in de middellangetermijnrichting. Tegelijkertijd heeft de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF ook een recordnettostroom gezien, wat het bearish sentiment op de markt heeft verergerd.</p>
<p>Wat betreft optiegegevens bespraken optiehandelaren de abnormale prestaties van de huidige marktvolatiliteit. Ondanks de scherpe daling is de volatiliteit van middellange en langetermijnopties niet effectief toegenomen. Dit kan erop wijzen dat de markt verwacht dat dit een eenmalige daling is in plaats van een trendverandering. Handelaren hebben opgemerkt dat de gamma-verdeling van ETH erg sterk is op $2.500, en de negatieve gammaverspreiding geeft aan dat de markt minder volatiliteit verwacht op de korte termijn.</p>
<p><strong>Ondo gaat een partnerschap aan met MasterCard om RWA-diensten te lanceren op MTN</strong></p>
<p>Het RWA-project Ondo Finance heeft zich aangesloten bij het Mastercard-netwerk om grensoverschrijdende betalingen te verbeteren. Het investeringsproduct OUSG (Short-Term US Government Bond Fund) van Ondo zal openstaan voor bedrijven op het Mastercard Multi-Token Network (MTN), waardoor ze rendement kunnen behalen op getokeniseerde activa, volgens officieel nieuws.</p>
<p>Er wordt gemeld dat het grootste deel van de activa van OUSG is geïnvesteerd in het Amerikaanse Dollar Institutional Digital Liquidity Fund (BUIDL) van BlackRock, het grootste op blockchain gebaseerde geldmarktfonds dat wordt gesteund door kortlopende Amerikaanse overheidsobligaties. Mastercard’s MTN combineert op API-gebaseerde blockchaintools om banken te helpen bij het vereenvoudigen van binnenlandse en grensoverschrijdende transacties.</p>
<p>Fed’s Bostic: Fed kan dit jaar twee keer de rente verlagen, onzekerheid is hoog</p>
<p>De heer Bostic van de Fed zei dat hij verwacht dat er dit jaar twee renteverlagingen zullen plaatsvinden, maar er kunnen meer of minder renteverlagingen plaatsvinden te midden van een ‘alomtegenwoordige’ onzekerheid. Hij verwacht niet dat de inflatie plotseling zal exploderen, en zijn algehele inflatievoorspelling is een hobbelig neerwaarts pad. Hij gelooft dat de inflatie zal bewegen naar het 2% doel, maar het is er nog niet. Het doel van de Fed is om het 2,0% doel te bereiken zonder de arbeidsmarkt te schaden.</p>
<p>Bostic zei dat bedrijven optimistisch zijn over deregulering, maar zich zorgen maken over de impact van tarieven en wijzigingen in het immigratiebeleid. Daarnaast ziet hij tekenen van verlichting op de arbeidsmarkt. Bostic zei dat de huidige referentierentevoet matig restrictief is en zo moet blijven. Hij zei dat de economische vertraging een belangrijke zorg is vanwege de aanstaande beleidswijziging, maar bedrijven verwachten een solide economische groei in 2025.</p>
<h2 id="h2-Markttrends20KAITO20bereikte20een20nieuw20recordhoogte20tegen20de20trend20in20en20AI20Agent20track20steeg20over20het20algemeen975659"><a name="Markttrends: KAITO bereikte een nieuw recordhoogte tegen de trend in, en AI Agent track steeg over het algemeen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: KAITO bereikte een nieuw recordhoogte tegen de trend in, en AI Agent track steeg over het algemeen.</h2><h3 id="h3-Markt20Hotspots10850"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>KAITO kwam in opstand tegen de trend en bereikte $2,6 binnen de dag, waarmee een nieuw recordhoogte werd bereikt. KAITO werd de best presterende nieuwe munt van de afgelopen week. Kaito AI heeft een sterke achtergrond van investeerders en werd op de eerste dag van de lancering genoteerd op belangrijke mainstream handelsplatforms, waaronder Gate.io. Bovendien heeft het Kaito AI-team een goede controle over het operationele ritme en lanceerde het aan het begin van deze week sociale kaarten van verschillende niveaus, wat ook kapitaalaankopen tijdens de marktdownturn stimuleerde. Kaito AI is een op AI gebaseerde <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> informatie integratietool die tot doel heeft de huidige problemen van informatiefragmentatie in de cryptobranche op te lossen;</p>
<p>Trending AI Agent tokens zoals ALCH, PIPPIN, AIXBT en  stegen allemaal, waarbij ALCH een stijging van meer dan 200% in drie dagen bereikte; Nvidia publiceerde vanmorgen vroeg zijn financieel rapport, met aanzienlijk hogere inkomsten dan verwacht, wat tot op zekere hoogte het vertrouwen van de markt in het AI-traject versterkte. AI moet het meest gangbare verhaal zijn in de toekomstige crypto-industrie.</p>
<h3 id="h3-Mainstream20Munten430927"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC zakte ooit onder de $82.500 gedurende de dag. BTC ETF heeft een grote nettostroom gezien gedurende een week op rij, met een dagelijkse uitstroom van meer dan $1,1 miljard eergisteren. Vanuit het perspectief van ETF-fondsen is het marktvooruitzicht zwak; de AHR999-index van vandaag is 0,86, wat aangeeft dat het geschikt is voor langetermijnbeleggers om regelmatig te investeren;</p>
<p>ETH is de afgelopen drie opeenvolgende dagen gedaald en consolideert momenteel rond $2.350. Het kan lang duren om te herstellen van de slechte markt. ETHD (ETH-marktaandeel) staat op het punt om onder de 10% te vallen. ETHD is sinds 2021 een neerwaartse trend. Vergeleken met het historische hoogtepunt van 23% in 2021 is ETHD met meer dan 55% gedaald;</p>
<p>Altcoins volgen de markt niet langer naar beneden, en de AI Agent track steeg tegen de trend in onder invloed van het financiële rapport van Nvidia. Trending Altcoins hebben mogelijk hun dieptepunt bereikt.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20schatkistrendementcurve20omgekeerd20verwachtingen20van20Fedrente20verhoogd426841"><a name="Macro Nieuws: Amerikaanse schatkistrendementcurve omgekeerd, verwachtingen van Fed-rente verhoogd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse schatkistrendementcurve omgekeerd, verwachtingen van Fed-rente verhoogd</h2><p>De drie belangrijkste Amerikaanse aandelenindexen stegen en daalden, waarbij de S&amp;P 500 met 0,01% steeg naar 5956,06 punten, de Dow Jones met 0,43% daalde naar 43433,12 punten en de Nasdaq met 0,26% steeg naar 19075,26 punten. Het referentiepunt van de 10-jaars Treasury-rente bedroeg 4,25% en het referentiepunt van de 2-jaars Treasury-rente, die het meest gevoelig is voor de beleidsrente van de Fed, bedroeg 4,05%.</p>
<p>Daarnaast daalde het rendement op de 10-jarige Amerikaanse schatkist voor de zesde opeenvolgende dag, waardoor het dit jaar een dieptepunt bereikte en onder het rendement op de 3-maands schatkist daalde, waardoor een ‘omgekeerde yield curve’ ontstond. De omgekeerde yield curve is altijd een van de gebruikelijke indicatoren geweest voor het voorspellen van een economische recessie, wat de marktverwachtingen voor renteverlagingen opnieuw heeft aangewakkerd. De markt verwacht momenteel dat de Federal Reserve de rente dit jaar met minstens 0,5 procentpunt zal verlagen.</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 beleggingssuggestie. Alle beleggingen 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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>