RGFnZWxpamtzIE5pZXV3cyB8IEJUQyBXaGl0ZSBQYXBlciBpcyBhbCAxNiBqYWFyIGdlcHVibGljZWVyZCwgQlRDIEVURidzIHphZ2VuIG9wbmlldXcgZWVuIGRhZ2VsaWprc2UgaW5zdHJvb20gdmFuIGJpam5hICQ5MDAgbWlsam9lbg==

2024-10-31, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/173034892810.31.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Het20Bitcoin20whitepaper20is20al201620jaar20gepubliceerd20BTC20ETFs20zagen20dagelijks20een20instroom20van20bijna2090020miljoen325490"><a name="Crypto Dagelijkse Samenvatting: Het Bitcoin whitepaper is al 16 jaar gepubliceerd, BTC ETF’s zagen dagelijks een instroom van bijna $900 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> whitepaper is al 16 jaar gepubliceerd, BTC ETF’s zagen dagelijks een instroom van bijna $900 miljoen</h2><p>Volgens gegevens van Farside Investor is de netto instroom van Amerikaanse <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s bedroeg gisteren $892 miljoen. BlackRock IBIT had gisteren een nettostroom van $871 miljoen. Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s kenden een kleine instroom van miljoenen dollars.</p>
<p><strong>Het Bitcoin whitepaper is al 16 jaar gepubliceerd</strong></p>
<p>Het is 16 jaar geleden sinds Satoshi Nakamoto het Bitcoin-witboek ‘Bitcoin: Een Peer-to-Peer Elektronisch Cashsysteem’ op de P2P Foundation-website heeft uitgebracht.</p>
<p>Het Bitcoin-netwerk werd officieel gelanceerd op 3 januari 2009, met een oorspronkelijke transactieprijs van $0,0008. Tegenwoordig is Bitcoin geleidelijk aan meer dan 90 miljoen keer in waarde gestegen sinds de lancering. Volgens de marktgegevens van Gate.io is de huidige prijs van Bitcoin $72.309, met een totale marktkapitalisatie van $1,43 biljoen.</p>
<p><strong>De Bitcoin-bezittingen van de Amerikaanse spot Bitcoin ETF’s zijn meer dan 1 miljoen</strong></p>
<p>Volgens Trader T monitoring hebben de BlackRock Bitcoin ETF’s een nieuw hoogtepunt bereikt in de zelf gelanceerde instroom, met een totaal van $875 miljoen, wat resulteert in meer dan 1 miljoen Bitcoin-holdings in Amerikaanse spot Bitcoin ETF’s. Volgens Bloomberg Terminal had BlackRock IBIT gisteren een netto instroom van $875 miljoen, wat een historisch hoogtepunt is.</p>
<p><strong>CICC: De Amerikaanse economie gaat richting een zachte landing, en de Fed hoeft voorlopig de rente niet significant te verlagen</strong></p>
<p>Volgens het CICC-onderzoeksrapport bedroeg het werkelijke BBP van de Verenigde Staten in het derde kwartaal van 2024 een jaarlijks groeipercentage van 2,8%, iets lager dan de marktverwachting van 3,0%, en iets lager dan de 3,0% in het tweede kwartaal, maar nog steeds een positieve uitkomst. Bij het bekijken van de subonderdelen wijzen sterke persoonlijke consumptie-uitgaven, uitbreiding van investeringen in bedrijfsmiddelen en versnelling van de export en overheidsuitgaven erop dat de Amerikaanse economie nog steeds gezond groeit. Relatief zwakker zijn investeringen in onroerend goed en bouwinvesteringen, wat aangeeft dat hoge rentetarieven nog steeds een beperkend effect hebben.</p>
<p>Bovendien betekent de verdere daling van de inflatie in het derde kwartaal dat de Amerikaanse economie op weg is naar een zachte landing. Wij geloven dat de Federal Reserve voorlopig niet significant hoeft te bezuinigen op de rente. Verwacht wordt dat de rente volgende week met 25 basispunten zal worden verlaagd, en of de renteverlaging in december wordt overgeslagen, zal afhangen van de voortgang van de inflatie.</p>
<h2 id="h2-Markttrends20Gate20lanceerde20Pumpfun20premarket20trading20TIA20daalde20scherp20na20het20ontgrendelen20van20massieve20munten394293"><a name="Markttrends: Gate lanceerde Pumpfun pre-market trading, TIA daalde scherp na het ontgrendelen van massieve munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Gate lanceerde Pumpfun pre-market trading, TIA daalde scherp na het ontgrendelen van massieve munten</h2><h3 id="h3-Markt20Hotspots52594"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Gate lanceerde gisteren Pumpfun voor pre-market trading. Pumpfun is een meme launchpad op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> een ketting die de afgelopen zes maanden bekende tokens heeft gecreëerd zoals BILLY, MICHI en MC;</p>
<p>De modulaire blockchain TIA heeft een aanzienlijke daling meegemaakt, omdat het gisteren om 20.00 uur tokens ter waarde van $1 miljard heeft vrijgegeven. De kortetermijnverkoopdruk op de markt is toegenomen, wat wijst op een normale daling bij het vrijgeven. TIA heeft mogelijk geen sterke opwaartse trend op korte termijn;</p>
<p>ETH is al 5 opeenvolgende dagen gestegen, maar de totale stijging is slechts 10%. De gemeenschap gelooft dat ETH een doemsdagtank is geworden in de cyclische markt en dat de markt binnenkort mogelijk een kortetermijndaling zal ervaren omdat de instroom van ETH ETF-fondsen traag is en ETH niet meer aandacht van fondsen heeft gekregen. Momenteel worden alleen aankopen van beleggingsfondsen op de beurs gedaan.</p>
<h3 id="h3-Populaire20Munten712144"><a name="Populaire Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Populaire Munten</h3><p>BTC handelt zijwaarts op een hoog niveau en na twee weken van aanzienlijke instroom zijn de kapitaalinstromen naar BTC ETF’s tijdelijk vertraagd. Echter, met verwachtingen van een renteverlaging door de Fed en nieuws over een mogelijke overwinning voor crypto-vriendelijke president Trump, blijft het vooruitzicht voor de toekomst optimistisch;</p>
<p>ETH brak kortstondig door de $2.700 voordat het terugviel, en de trage prestaties van ETH ETF’s worden ook weerspiegeld in de prijs van ETH;</p>
<p>Altcoins dalen over het algemeen en de markt mist toonaangevende tokens die op korte termijn de markt kunnen leiden. Na de doorbraak van BTC naar een nieuw hoogtepunt, kunnen Altcoins een collectieve opwaartse trend hebben.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20sluiten20allemaal20lager202jarige20Amerikaanse20schatkistrendementen20stijgen20lichtjes192962"><a name="Macro nieuws: Amerikaanse aandelen sluiten allemaal lager, 2-jarige Amerikaanse schatkistrendementen stijgen lichtjes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen sluiten allemaal lager, 2-jarige Amerikaanse schatkistrendementen stijgen lichtjes</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager, waarbij de S&amp;P 500-index met 0,33% daalde tot 5.813,67 punten; De Dow Jones Industrial Average daalde met 0,22% tot 42.141,54 punten; De Nasdaq-index daalde met 0,56% tot 18.607,93 punten. Het referentiepunt voor de 10-jarige Treasury-rente is 4,29%, terwijl de 2-jarige Treasury-rente, die het meest gevoelig is voor het rentebeleid van de Federal Reserve, 4,15% bedraagt.</p>
<p>Op het gebied van economische gegevens heeft het ADP Research Institute op 30 oktober, in samenwerking met het Stanford Digital Economy Lab, gegevens vrijgegeven waaruit blijkt dat de werkgelegenheid bij ADP in de Verenigde Staten in oktober met 233.000 mensen is veranderd, wat hoger is dan de voorspelling van 111.000 mensen door bijna alle door de media ondervraagde economen, en de vorige waarde was 143.000 mensen. Bovendien bedroeg het geannualiseerde kwartaalpercentage van het BBP in het derde kwartaal van de Verenigde Staten 2,8%, lager dan de marktverwachting van 3%, en dit is ook de eerste keer sinds het derde kwartaal van 2023 dat deze indicator onder de marktverwachtingen is gedaald.</p>
<p>De sterke prestaties van de arbeidsmarkt en de aanhoudende afkoeling van de inflatie zijn nog steeds hoger dan verwacht. Sommige analisten geloven dat dit ertoe kan leiden dat functionarissen van de Federal Reserve kiezen voor minder agressieve renteverlagingen. Na de publicatie van de gegevens verwachtten de meeste markten dat de Federal Reserve de rente in november met 25 basispunten zou verlagen.</p>
<div class="blog-details-info"><div>Auteur:<strong>Icing</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>