RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYtZm9uZHNlbiBibGlqdmVuIGdyb3RlIGluc3Ryb21lbiBvbnR2YW5nZW4sIFJFRUYgZGFhbGRlIG1ldCA3MCU=

2024-10-16, 04:28

<p><img src="https://gimg2.gateimg.com/image/article/172905276310.16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFinflows20overschreden2030020miljoen20EIGEN20verwelkomt20grote20ontgrendeling20vandaag646853"><a name="Crypto Dagelijkse Samenvatting: BTC ETF-inflows overschreden $300 miljoen, EIGEN verwelkomt grote ontgrendeling vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF-inflows overschreden $300 miljoen, EIGEN verwelkomt grote ontgrendeling vandaag</h2><p>Volgens gegevens van Farside Investor, Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hadden gisteren een nettostroom van $371,66 miljoen. De instroom van BlackRock’s IBIT was $289 miljoen en de instroom van Fidelity’s FBTC was $35 miljoen. De Amerikaanse spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF had gisteren een nettostroom van $12,7 miljoen uitstroom.</p>
<p><strong>Bitwise Chief Investment Officer: Een groot aantal fondsen kijkt uit de markt en wacht om binnen te komen nadat het risico van regulering van Amerikaanse cryptocurrency is verminderd.</strong></p>
<p>Matt Hougan, Chief Investment Officer van Bitwise, verklaarde dat de recente opmerkingen van de Amerikaanse vicepresident Harris over cryptocurrency aangeven dat als toezichthouders groen licht geven, investeerders zich zullen haasten naar de digitale activamarkt.</p>
<p>Op maandag beloofde Harris een regelgevend kader te ondersteunen dat zwarte investeringen en eigendom van cryptocurrency beschermt. Hougan wees er in een blogpost op dat het voorstel van Harris samenviel met een stijging van 5% in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> prijzen stegen op maandag, met $555,8 miljoen dat in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETFs stroomde, de grootste instroom sinds 4 juni.</p>
<p>Hij voegde eraan toe: “Ongeacht wat Harris zei, vertelt de prijstrend van de dag me dat er veel fondsen aan de zijlijn staan te wachten om het alarm te wissen en de markt binnen te gaan.”</p>
<p><strong>De waarschijnlijkheid dat de Fed de rente met 25BP zal verlagen in november is 90,6%</strong></p>
<p>Volgens CME’s “FedWatch” is de waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten zal verlagen tegen november 90,6%, en de waarschijnlijkheid dat de huidige rente ongewijzigd blijft 9,4%. De waarschijnlijkheid van een cumulatieve renteverlaging van 25 basispunten tegen december is 13,3%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten is 86,2%.</p>
<p><strong>EIGEN verwelkomt vandaag grote ontgrendeling</strong></p>
<p>Het restakingsprotocol Eigenlayer (EIGEN) ontgrendelde vandaag om 3 uur ‘s ochtends 11,22 miljoen tokens ter waarde van ongeveer $41,85 miljoen, goed voor 6,01% van de liquiditeit. De huidige omloopmarktwaarde van EIGEN is ongeveer $660 miljoen, waarmee het op de 102e plaats staat wat betreft marktkapitalisatie.</p>
<p>EigenLayer is een protocol gebouwd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk dat het nieuwe concept van ‘re-staking’ gebruikt om de veiligheid en praktische toepasbaarheid van het netwerk uit te breiden naar andere projecten in de industrie.</p>
<h2 id="h2-Markttrends20REEF20daalde20met207020Altcoins20over20het20algemeen20aangepast6216"><a name="Markttrends: REEF daalde met 70%, Altcoins over het algemeen aangepast" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: REEF daalde met 70%, Altcoins over het algemeen aangepast</h2><h3 id="h3-Markt20Hotspots314858"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De opslagconcepttoken STORJ is met meer dan 25% gestegen, en de opslagsector heeft de afgelopen paar rondes van markttrends veel aandacht gekregen, vaak als een onafhankelijke markt naar voren gekomen;</p>
<p>Nieuwe openbare ketenprojecten zoals SUI en SAGA hebben een aanzienlijke daling doorgemaakt, waarbij on-chain data aantoont dat adressen met $1 miljard aan SUI blijven verkopen, wat de gemeenschap gelooft dat het officiële verkoopgedrag van Sui’s munten is;</p>
<p>Het meme-project DEEP on the chain is driemaal gestegen. DEEP is het aggregatiehandelsplatform van Sui Chain en is nu gelanceerd op Gate.io.</p>
<h3 id="h3-Gangbare20munten413268"><a name="Gangbare munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare munten</h3><p>Nadat het $68.000 naderde, daalde BTC snel terug naar $65.000 en keerde daarna terug naar boven $67.500. BTC-aankopen waren sterk en ETF-fondsen bleven doorgaan met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> in;</p>
<p>ETH prestaties blijven achter bij BTC, nog steeds consolideren rond $2.600, met kleine uitstroom van ETH ETF’s;</p>
<p>Altcoins vielen over het algemeen, waarbij de vroege marktleiderstoken REEF binnen een dag met 70% daalde, waarvan de meeste zich in het aanpassingsbereik bevonden.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20gezamenlijk20lager20af20en20de20wereldwijde20marktonzekerheid20nam20toe403010"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager af en de wereldwijde marktonzekerheid nam toe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager af en de wereldwijde marktonzekerheid nam toe</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager, waarbij de S&amp;P 500-index met 0,76% daalde tot 5.815,26 punten; De Dow Jones Industrial Average daalde met 0,75% tot 42.740,42 punten; De Nasdaq-index daalde met 1,01% tot 18.315,59 punten. Het referentiepunt van de 10-jaars Treasury-opbrengsten bedraagt 4,03%, terwijl de opbrengsten van de 2-jaars Treasury, die het meest gevoelig zijn voor het Fed-beleidstarief, 3,95% bedragen. De Amerikaanse aandelenmarkt sloot lager op dinsdag (15 oktober), voornamelijk als gevolg van de onverwachte publicatie van het financiële rapport van het Nederlandse lithografiemachinebedrijf ASML over het derde kwartaal, dat achterbleef bij de verwachtingen.</p>
<p>Op het nieuwsfront beweerde Noord-Korea dat door de provocerende acties van Zuid-Korea meer dan 1,4 miljoen jeugdliga-kadetten en jonge studenten uit het hele land zich hebben aangemeld om toe te treden tot of terug te keren naar het leger, waardoor de marktonzekerheid wordt verergerd. Bovendien hebben Israëlische functionarissen verklaard dat ze mogelijk Iraanse militaire bases of overheidsgebouwen zullen aanvallen, waardoor de spanningen in het Midden-Oosten verder toenemen.</p>
<p>Over het algemeen is de wereldmarkt onzekerder geworden en zijn investeerders voorzichtiger geworden met het aanhouden van risicovolle activa. In deze context zijn veilige haven activa zoals goud in trek en sluiten internationale edelmetaalfutures over het algemeen hoger. Marktpartijen houden nauwlettend de ontwikkelingen in geopolitieke situaties en veranderingen in mondiale economische gegevens in de gaten om overeenkomstige investeringsbeslissingen te nemen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijs</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>