RGFnZWxpamtzIG5pZXV3cyB8IFBvd2VsbCdzIGhhdmlrYWNodGlnZSB0b2VzcHJhYWsgdHJvZiB2ZXJ3YWNodGluZ2VuIHZhbiByZW50ZXZlcmxhZ2luZ2VuLCBCVEMgc3RlZWcgZW4gdmllbCB2ZXJ2b2xnZW5zLCB3YXQgbGVpZGRlIHRvdCBtYXJrdGluc3RvcnRpbmc=

2024-11-15, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/173164337811.15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20ETHBTC20bereikt20nieuw20dieptepunt20in20bijna20drie20jaar20Powells20havikachtige20opmerkingen20ondermijnen20verwachtingen20van20renteverlagingen649817"><a name="Crypto Dagelijkse Samenvatting: ETH/BTC bereikt nieuw dieptepunt in bijna drie jaar, Powell’s havikachtige opmerkingen ondermijnen verwachtingen van renteverlagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: ETH/BTC bereikt nieuw dieptepunt in bijna drie jaar, Powell’s havikachtige opmerkingen ondermijnen verwachtingen van renteverlagingen</h2><p>Volgens de gegevens van Farside Investor, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot-ETF’s hadden gisteren een nettostroom van $220 miljoen, waaronder $127 miljoen van BlackRock IBIT-gegevens, $192 miljoen van Fidelity FBTC, $161 miljoen van Ark ARKB, en $113 miljoen van Bitwise BITB.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s kenden een uitstroom van $4 miljoen. De instroom bij BlackRock’s ETHA was $19 miljoen en de uitstroom bij Grayscale ETHE was $21.9 miljoen.</p>
<p><strong>Gegevens: ETH/BTC wisselkoers bereikte het laagste punt sinds april 2021 en raakte 0,03462</strong></p>
<p>Volgens de marktinformatie van Gate.io is de wisselkoers ETH/BTC gedaald naar 0,03462 en nu gerapporteerd op 0,03468, met een daling van 3,42% in 24 uur, waarmee het zijn laagste punt heeft bereikt sinds april 2021.</p>
<p><strong>Na de verkiezingsoverwinning van Trump trokken spot ETF’s $4,7 miljard aan instroom aan, met een nettostroom van $28,3 miljard voor de hele periode</strong></p>
<p>Volgens TheBlock bedraagt het cumulatieve handelsvolume van de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF heeft sinds de lancering in januari van dit jaar meer dan $500 miljard bereikt. BlackRock IBIT vestigde op 13 november een nieuw dagelijks handelsvolume record van $5,2 miljard, waarmee het vorige record van 1.253 dagen werd verbroken dat in slechts 211 dagen werd vastgehouden door IEMG-fondsen met een vermogensomvang van meer dan $40 miljard.</p>
<p>Gegevens tonen aan dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s sinds het begin van deze week een netto instroom van $2,4 miljard hebben ontvangen. Sinds de verkiezingsoverwinning van Trump hebben ETF’s $4,7 miljard aan instroom aangetrokken, met een totale netto instroom van $28,3 miljard sinds de notering. De beheerschaal van alle Bitcoin ETF’s bedraagt ongeveer $89 miljard, waarbij IBIT $41,1 miljard bereikt en op de eerste plaats staat.</p>
<p><strong>Powell: Fed hoeft niet te “haasten” om de rente te verlagen</strong></p>
<p>Federal Reserve-voorzitter Powell verklaarde dat de Fed vanwege de sterke Amerikaanse economie niet hoeft te “haasten” om de rente te verlagen en “zorgvuldig zal observeren” om ervoor te zorgen dat bepaalde inflatie-indicatoren binnen aanvaardbare niveaus blijven.</p>
<p>Powell herhaalde dat het rentetraject van de Federal Reserve afhankelijk zal zijn van aankomende gegevenspublicaties en de evolutie van het economisch vooruitzicht. Hij zei dat het inflatiepercentage de doelstelling van 2% van de Federal Reserve nadert, maar nog niet is bereikt. De Federal Reserve zal de kernindicatoren van inflatie in goederen en diensten, exclusief huisvesting, nauwlettend in de gaten houden, die de afgelopen twee jaar zijn gedaald. “We verwachten dat deze indicatoren in de nabije toekomst zullen blijven schommelen, en de weg naar het Fed-doel van 2% kan soms hobbelig zijn. We geloven echter nog steeds dat we op de goede weg zijn wat betreft inflatie.”</p>
<h2 id="h2-Markttrends20PNUT20steeg20en20viel20vervolgens20LTC20maakte20gebruik20van20het20memeconcept20om20de20markt20te20trekken527224"><a name="Markttrends: PNUT steeg en viel vervolgens, LTC maakte gebruik van het meme-concept om de markt te trekken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: PNUT steeg en viel vervolgens, LTC maakte gebruik van het meme-concept om de markt te trekken</h2><h3 id="h3-Markt20Hotspots597916"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De goed gevestigde POW-token LTC steeg en het officiële Twitter-account kondigde aan dat LTC een meme-coin is geworden, met volledige entertainmenteffecten; Marktbeleggingen geven over het algemeen de voorkeur aan sterk circulerende meme-coins en veel oude projecten maken gebruik van het meme-concept om het marktsentiment te stimuleren, wat binnen een korte periode zijn hoogtepunt kan bereiken;</p>
<p>De AI-concepten meme ACT en GOAT presteerden goed op de markt, met aanzienlijke schommelingen in de intraday amplitude en frequente situaties van herstel; ACT overtrof ooit een marktkapitalisatie van $900 miljoen, terwijl GOAT werd geblokkeerd door een marktkapitalisatie van $1 miljard. Als de toonaangevende tokens van AI-memes is er alleen ruimte voor AI-memes met een kleine marktkapitalisatie om te groeien wanneer hun marktkapitalisatie een grotere groei doormaakt.</p>
<h3 id="h3-Gangbare20munten243224"><a name="Gangbare munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare munten</h3><p>BTC is in een kortetermijn aanpassingsbereik getreden en consolideert momenteel rond de $88.000. Het marktsentiment is de laatste tijd te heet geweest en een tijdelijke aanpassing is bevorderlijker voor toekomstige marktvolatiliteit;</p>
<p>ETH is de afgelopen drie opeenvolgende dagen gedaald en bevindt zich momenteel rond $3.050. De wisselkoers ETH/BTC is opnieuw sterk gedaald en er zal pas een moment van prestatie zijn voor ETH nadat BTC een historisch hoogtepunt bereikt;</p>
<p>Altcoins zijn over het algemeen gedaald, en de afgelopen dagen hebben sterke munten zoals PNUT en WIF zich aangepast vanwege hun te grote korte termijn winsten.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20gezamenlijk20lager20waarbij20de20waarschijnlijkheid20van20een20renteverlaging20door20de20Fed20daalde20naar20587590740"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, waarbij de waarschijnlijkheid van een renteverlaging door de Fed daalde naar 58,7%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, waarbij de waarschijnlijkheid van een renteverlaging door de Fed daalde naar 58,7%.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager, waarbij de S&amp;P 500-index met 0,61% daalde tot 5.949,17 punten; De Dow Jones Industrial Average daalde met 0,47% tot 43.750,86 punten; De Nasdaq-index daalde met 0,64% tot 19.107,65 punten. Het referentiepunt van de 10-jarige Treasury-rente bedraagt 4,43%, terwijl het rendement van de 2-jarige Treasury, dat het meest gevoelig is voor het rentebeleid van de Federal Reserve, 4,34% bedraagt.</p>
<p>Fed-voorzitter Powell heeft donderdag een geschreven toespraak gehouden in Dallas, waarin hij verklaarde dat de recente prestaties van de Amerikaanse economie ‘heel goed’ zijn, waardoor de centrale bank ruimte heeft om de rentevoeten voorzichtig te verlagen. Powell zei: ‘De economie heeft geen signalen gegeven dat er dringend behoefte is aan een verlaging van de rentevoeten en de betere economische omstandigheden stellen ons in staat om voorzichtig te handelen bij het nemen van beslissingen. De inflatie ligt dichter bij ons langetermijndoel van 2%, maar is nog niet bereikt. We zijn toegewijd aan het vervullen van deze missie en met een vrij evenwichtige arbeidsmarkt en goed verankerde inflatieverwachtingen verwacht ik dat de inflatie verder zal dalen naar ons streefdoel van 2%, hoewel er af en toe hobbels kunnen zijn.’ Powell heeft geen commentaar gegeven over de mogelijkheid van een renteverlaging tijdens de vergadering in december. Volgens de observaties van de CME Federal Reserve is de waarschijnlijkheid van een renteverlaging van 25 basispunten door de Fed in december 58,7%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijslaag</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 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 Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>