RGFnZWxpamtzIG5pZXV3cyB8IERlIEZlZCB6YWwgbW9yZ2Vub2NodGVuZCBoYWFyIHJlbnRlYmVzbHVpdCBiZWtlbmRtYWtlbiwgZGUgaG9vZ3N0ZSBpbnRyYWRheS10b2VuYW1lIHZhbiBCTVQgb3ZlcnNjaHJlZWQgMTAwJQ==

2025-03-19, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/174235503813.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20CME20SOLfutures20handel20op20de20eerste20dag20was20koud20de20Fed20zal20morgenochtend20de20rentebeslissing20aankondigen441840"><a name="Crypto Dagelijkse Samenvatting: CME SOL-futures handel op de eerste dag was koud, de Fed zal morgenochtend de rentebeslissing aankondigen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: CME SOL-futures handel op de eerste dag was koud, de Fed zal morgenochtend de rentebeslissing aankondigen</h2><p>Volgens de gegevens van Farside Investors bedraagt de totale nettostroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs yesterday was $208 miljoen, waarvan BlackRock IBIT een instroom had van $217 miljoen en ARKB een uitstroom had van $9 miljoen. BTC ETF’s hadden twee opeenvolgende dagen een nettostroom van meer dan $200 miljoen, maar BTC bevindt zich nog steeds in een smalle fluctuatiebereik.</p>
<p>Gisteren, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF had a total outflow of $52.4 miljoen, waarvan BlackRock ETHA een uitstroom had van $39.8 miljoen en Grayscale ETHE een uitstroom had van $9.3 miljoen. De ETH/BTC-wisselkoers staat momenteel op 0.0233, wat bijna het laagste niveau in bijna 4 jaar is.</p>
<p><strong>De Federal Reserve zal morgenochtend haar rentebesluit bekendmaken, met slechts een kans van 1% op een renteverlaging in maart</strong></p>
<p>Volgens de gegevens van CME’s ‘FedWatch’ zal de Federal Reserve morgen om 2 uur ‘s ochtends Peking-tijd haar rentebesluit bekendmaken. De waarschijnlijkheid dat de Federal Reserve de rentetarieven in maart met 25 basispunten zal verlagen, is slechts 1%, en de waarschijnlijkheid van handhaving op ongewijzigd is 99%.</p>
<p>De waarschijnlijkheid dat de Federal Reserve de rentetarieven met 50 basispunten zal verlagen tegen mei is 0,2%, de waarschijnlijkheid van het verlagen van de rentetarieven met 25 basispunten is 18,6%, en de waarschijnlijkheid van het handhaven van ongewijzigde rentetarieven is 81,2%.</p>
<p><strong>Analyse van belangrijke prijsniveaus vóór de rentevergadering van de Fed: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blijft steken onder $85.000</strong></p>
<p>Volgens de marktgegevens van Gate.io, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> slaagde er niet in om op 17 maart opnieuw het weerstandsniveau van $ 85.000 te bereiken. In de afgelopen vijf dagen schommelden de intraday highs altijd tussen $ 84.000 en $ 85.200, maar slaagden ze er niet in om boven $ 84.600 te komen. Nu de FOMC-vergadering van de Federal Reserve (het rentebesluit wordt op 20 maart om 2 uur ‘s nachts Peking-tijd bekendgemaakt) nadert, is de markt een “niemandsland” binnengegaan - prijsschommelingen zijn vol onzekerheid en het long-short-spel is geïntensiveerd. Volgens de CME FedWatch-tool is de kans op het handhaven van de huidige rente van 4,25% tot 4,50% 99% en is de kans op een renteverlaging van 25 basispunten slechts 1%. Hoewel de CPI (2,8%) en de PCE (2,5%-2,6%) nog steeds boven de doelstelling van 2% liggen, voldoen de meest recente gegevens niet aan de drempel voor een onmiddellijke renteverlaging; het werkloosheidspercentage (4,1%) en het bbp (2,3% in het vierde kwartaal van 2024) laten nog steeds zien dat de economie veerkrachtig is. Polymarket voorspelt dat de Fed vóór 30 april een einde zal maken aan de kwantitatieve verkrapping, wat de weg kan vrijmaken voor een renteverlaging in de zomer.</p>
<p>Analisten hebben verschillende standpunten. Anonieme analist SuperBitcoinBro wees erop dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in het ergste g de steunzone van $71.300 tot $73.800 zou kunnen testen. Analist Nebraskangooner gelooft dat de FOMC-uitslag onvoorspelbaar is en dat Bitcoin $86.250 moet herstellen om korte-termijn bullishness te bevestigen; anders zou het terug kunnen vallen naar $70.000. Powell zal een persconferentie houden na de aankondiging van het rentebesluit om 2 uur ‘s nachts Beijing tijd op 20 maart, en de markt richt zich op zijn uitspraken over inflatie en het pad van renteverlagingen.</p>
<p><strong>CME <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> futures eerste handelsdag was koud, ETF-goedkeuring kan moeilijk zijn om het succes van Bitcoin te repliceren</strong></p>
<p>Volgens TheBlock zijn de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>-futures van de Chicago Mercantile Exchange (CME) stilletjes gelanceerd op 17 maart, met een handelsvolume van slechts $12,3 miljoen op de eerste dag en een openstaand belang van $7,8 miljoen, veel minder dan de eerdere schitterende prestaties van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>-futures. K33 Research-analisten Vetle Lunde en David Zimmerman wezen in hun laatste rapport erop dat deze gegevens de koele houding van instellingen ten opzichte van altcoins weerspiegelen. Zelfs als de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ETF in de toekomst wordt goedgekeurd, kan het stimulerende effect op SOL-prijzen zwakker zijn dan de marktverwachtingen.</p>
<p>De lancering van CME-futures wordt vaak gezien als een voorbode van de goedkeuring van spot-ETF’s, maar analisten geloven dat zelfs als Solana ETF wordt gelanceerd, het moeilijk zal zijn om de opwinding van Bitcoin ETF in 2024 te repliceren. Bitcoin ETF werd geboren in de resonantieperiode van halveringsverwachtingen en macroverruiming, en de huidige markt mist vergelijkbare verhalen. Naast Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> heeft de institutionele derivatenmarkt van andere altcoins een zwakke groei, wat aangeeft dat onder macro-economische onzekerheid instellingen de voorkeur geven aan het toewijzen van ‘digitaal goud’ in plaats van hoogrisico-activa. De ‘commodity’-positionering van Bitcoin biedt een duidelijk compliance-pad, terwijl altcoins nog steeds in een grijs gebied zitten. Ondanks de korte termijn tegenslagen, blijft de ontwikkelaarsactiviteit en technologische innovatie van het Solana-ecosysteem nog steeds vooroplopen op veel openbare ketens. We verwachten dat het een schitterende prestatie zal leveren nadat de spot-ETF is goedgekeurd. De weg naar ‘institutionalisering’ van altcoins is echter nog steeds vol moeilijkheden.</p>
<h2 id="h2-Markttrends20EOS20steeg20met203020na20de20naamswijziging20en20de20hoogste20intraday20stijging20van20BMT20overschreed20100467786"><a name="Markttrends: EOS steeg met 30% na de naamswijziging, en de hoogste intraday stijging van BMT overschreed 100%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> steeg met 30% na de naamswijziging, en de hoogste intraday stijging van BMT overschreed 100%</h2><h3 id="h3-Markt20Hotspots233581"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Het goed gevestigde openbare ketenproject <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a> Netwerk heeft officieel zijn naam veranderd in Vaulta. Het nieuws zorgde ervoor dat <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> binnen een dag met 30% steeg. Volgens de officiële introductie zal Vaulta zich focussen op <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> bankwezen. Vaulta zal de oorspronkelijke technische infrastructuur van EOS Network behouden. Bovendien is Vaulta van plan om in mei van dit jaar aanvankelijk een tokenruil uit te voeren. Afgaand op de huidige marktfeedback, zitten investeerders vol verwachtingen voor de naamswijziging van EOS en de verandering van ontwikkelingsrichting. De aanhoudende sterke prestaties van de EOS-prijs in de komende maanden is echter een vroege gok op de toekomstige ontwikkeling van Vaulta.</p>
<p>BMT, de token van Bubblemaps, een tool op Gate.io <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, gestegen met meer dan 100% in de dag. Er werd aangekondigd dat het zou worden genoteerd op een reeks van belangrijke handelsplatforms, waaronder Gate.io, wat de stijging van BMT stimuleerde. De huidige circulerende marktwaarde van BMT is slechts $64 miljoen, waarmee het op de 439e plaats staat op de gehele markt. Sommige gemeenschappen zijn van mening dat BMT moet worden beschouwd als een meme met een zekere bruikbaarheid op <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain. Het is een nieuwe munt met een zekere marktpopulariteit en gebruikersscenario’s, en het kan in de toekomst worden blijven gevolgd.</p>
<h3 id="h3-Mainstream20Munten597320"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC bevindt zich nog steeds in een smalle bandbreedte van schommelingen, en er zal op korte termijn geen grote ommekeer zijn. Bovendien toont de AHR999-index aan dat de huidige prijs geschikt is voor langetermijnbeleggers om te investeren.</p>
<p>ETH bevindt zich ook in een nauwe range rond $1,900, met de dagelijkse lijn bijna vlak, en ETH convergeert en fluctueert, wachtend om een richting te kiezen.</p>
<p>Altcoins hebben wisselende prestaties, en <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain-projecten presteren over het algemeen beter dan andere openbare ketens.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelen20sloten20lager20de20Federal20Reserve20zal20haar20rentebesluit20van20maart20aankondigen515874"><a name="Macro Nieuws: Amerikaanse aandelen sloten lager, de Federal Reserve zal haar rentebesluit van maart aankondigen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelen sloten lager, de Federal Reserve zal haar rentebesluit van maart aankondigen</h2><p>De drie belangrijkste Amerikaanse aandelenindexen sloten gezamenlijk lager af, waarbij de S&amp;P 500 met 1,07% daalde tot 5.614,66 punten, de Dow Jones met 0,62% daalde tot 41.581,31 punten, en de Nasdaq met 1,71% daalde tot 17.504,12 punten. Het referentiepunt van de Amerikaanse 10-jaars staatsleningen bedroeg 4,29%, en het rendement op 2-jaars staatsleningen, dat het gevoeligst is voor het rentetarief van de Fed, bedroeg 4,04%.</p>
<p>Om 2 uur ‘s ochtends Beijing-tijd op donderdag zal de Federal Reserve haar tweedaagse monetair beleidsoverleg beëindigen en Voorzitter Powell zal de rentebeslissing en de laatste economische voorspellingssamenvatting aankondigen. Beleggers maken zich met name zorgen of er een risico op ‘stagflatie’ zal zijn, waarbij zowel de inflatie als de werkloosheidscijfers tegelijkertijd stijgen. De huidige marktzorgen zijn voornamelijk te wijten aan het feit dat het tariefbeleid de economische groei kan vertragen en consumentenprijzen kan opdrijven.</p>
<p>Sommige analisten zeiden dat als Powell een dovish signaal zou afgeven, wat aangeeft dat de Fed bereid was de rente snel te verlagen wanneer de economie vertraagde, de markt mogelijk positief zou reageren, maar de realiteit is dat de hoge inflatieomgeving de Fed in een moeilijke positie heeft gebracht. ‘Het huidige inflatieniveau ligt aanzienlijk hoger dan het streefcijfer. In dit g is het moeilijk voor Powell om een te dovish standpunt te tonen.’</p>
<p>De Fed wordt algemeen verwacht om deze week de referentierente onveranderd te houden op 4,25% tot 4,5%. Volgens de CME FedWatch-tool verwachten handelaren dat de Fed de rentetarieven twee of drie keer zal verlagen in het laatste kwartaal van 2025.</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>Deze artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies. Alle beleggingen 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 er naar Gate.io wordt verwezen. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>