RGFnZWxpamtzIG5pZXV3cyB8IEZvY3VzIG9wIHZhbmF2b25kJ3Mgd2Vya2dlbGVnZW5oZWlkc3JhcHBvcnQsIEJUQyBuYXV3ZWxpamtzIHZhc3RnZWhvdWRlbiBvcCAkNjAuMDAw

2024-10-04, 04:28

<p><img src="https://gimg2.gateimg.com/image/article/172801596510.4.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20hebben20een20nettoutstroom20van20ongeveer205420miljoen20ervaren20ETH20ETFs20hadden20een20nettoutstroom20van20bijna20320miljoen180329"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s hebben een nettoutstroom van ongeveer $54 miljoen ervaren, ETH ETF’s hadden een nettoutstroom van bijna $3 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s hebben een nettoutstroom van ongeveer $54 miljoen ervaren, ETH ETF’s hadden een nettoutstroom van bijna $3 miljoen</h2><p>Volgens Trader T monitoring is er op 3 oktober op de spotmarkt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF had een nettostroom van $54,03 miljoen, en de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF had een netto uitstroom van $3,2 miljoen.</p>
<p><strong>De waarschijnlijkheid dat de Fed de rentetarieven in november met 25BP verlaagt, is 62,5%</strong></p>
<p>Volgens CME’s ‘FedWatch’ is de waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten verlaagt tegen november 62,5%, en de waarschijnlijkheid dat de rente met 50 basispunten wordt verlaagd 37,5%. De waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten tegen december is 44,5%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 75 basispunten is 44,7%; De waarschijnlijkheid van een cumulatieve renteverlaging van 100 basispunten is 10,8%.</p>
<p><strong>Grijstinten gelanceerd <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Beleggingsfonds</strong></p>
<p>Het vermogensbeheerbedrijf Grayscale Investments heeft de lancering aangekondigd van een nieuw <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> governance-token AAVE-beleggingsfonds. Dit fonds is alleen open voor gekwalificeerde beleggers en is toegevoegd aan Grayscale’s enkelvoudige activa crypto-beleggingsproductlijn.</p>
<p><strong>Vitalik Buterin suggereert dat er inspanningen kunnen worden geleverd om de bandbreedtevereisten te verhogen en de minimumlimiet te verlagen naar 16 of 24 ETH.</strong></p>
<p>Mede-oprichter van Ethereum, Vitalik Buterin, verklaarde in een bericht dat ontwikkelaars misschien moeten erkennen dat 32ETH een hogere drempel is voor stakers dan bandbreedtevereisten, en de bandbreedtevereisten enigszins kunnen verhogen in ruil voor het verlagen van de minimale inzetstortingslimiet tot bijvoorbeeld 16 of 24ETH. Zodra <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> de peerdas-upgrade heeft voltooid, kan de minimale stortingslimiet ook worden verlaagd tot 1 ETH.</p>
<p><strong>Documentaire regisseur Cullen Hoback beweert dat de HBO-documentaire de oprichter van Bitcoin, Satoshi, zal ontmaskeren</strong></p>
<p>Documentaire regisseur Cullen Hoback en HBO hebben onlangs de première aangekondigd van hun aankomende film “Money Electric: The <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Mystery” en zinspeelden erop dat de ware identiteit van Bitcoin-maker Satoshi Nakamoto eindelijk onthuld kan worden. Hij beweerde daarin dat hij verschillende auteurs van de QAnon samenzweringstheorie heeft geïdentificeerd.</p>
<p><strong>Gegevens: Meer dan 3.700 rekeningen in Zuid-Korea bezitten cryptocurrency ter waarde van meer dan $750.000</strong></p>
<p>Volgens rapporten hebben bijna 3759 mensen in Zuid-Korea crypto-accounts ter waarde van meer dan 1 miljard Koreaanse won (ongeveer $750.000). Onder hen zijn ongeveer 185 investeerders tussen de 20 en 29 jaar oud, en deze jonge crypto-investeerders hebben in totaal ongeveer 967,2 miljard Koreaanse won ($739 miljoen), met een gemiddelde van ongeveer 5,2 miljard Koreaanse won ($3,9 miljoen) per persoon.</p>
<h2 id="h2-Markttrends20BTC20bleef20nauwelijks20op206000020markt20verschoof20van20Sui20naar20hype20Aptos924542"><a name="Markttrends: BTC bleef nauwelijks op $60.000, markt verschoof van Sui naar hype Aptos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bleef nauwelijks op $60.000, markt verschoof van Sui naar hype Aptos</h2><h3 id="h3-Markt20Hotspots463694"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><ul>
<li>Het token van het Sui-ecosysteem van de high-performance Layer1 openbare blockchain is gisteravond gestopt met zijn sterke opwaartse trend van een maand en begon gisteravond naar beneden aan te passen. Fondsen zijn overgestapt naar ophef over de <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> sector, die ook een Move-serie is. De circulerende marktwaarde van deze sector is met 6,69% gestegen, waarbij <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> (APT), Cellana Finance (CELL) en Thala (THL) respectievelijk 24-uurswinsten van 3,63%, 11,03% en 18,74% hebben ervaren.</li></ul>
<p>-De privacysector kende een lichte stijging, met toonaangevende spelers <a href="/price/monero-xmr" rel="nofollow noopener noreferrer" target="_blank">Monero</a> (XMR), Aleo (ALEO), en <a href="/price/dash-dash" rel="nofollow noopener noreferrer" target="_blank">Dash</a>(DASH) ervaart respectievelijk winsten van 4,6%, 6,9% en 1,0% in de afgelopen 24 uur.</p>
<p>-Dankzij de lancering van een specifiek investeringsfonds door Grayscale is Aave (AAVE) opnieuw in het rood gedraaid en gestegen, met een stijging van 1,1% in 24 uur. Aave is het leidende protocol in de DeFi uitleenarena. Sinds een nieuw voorstel in juli van dit jaar met betrekking tot conversie van activeringskosten en terugkoop van tokens van de openbare markt, zijn tokens zeer gewild en de populariteit is tot op de dag van vandaag voortgezet.</p>
<h3 id="h3-Gangbare20munten260331"><a name="Gangbare munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare munten</h3><p>Na 4 opeenvolgende dagen van daling, bereikte BTC het dieptepunt en steeg gisteren lichtjes, met aanzienlijke steun van het gehele niveau van $60.000 en het 60-daags voortschrijdend gemiddelde. Positief sentiment hoopt zich geleidelijk op;</p>
<p>-ETH is de afgelopen 6 opeenvolgende dagen gedaald en de uitgifte van Eigenlayer coins en ETH spot ETFs hebben de verbetering van ETH-prijzen niet effectief bevorderd. ETH/BTC is opnieuw dichtbij zijn vorige dieptepunt gekomen, wat de voorkeur van BTC-fondsen in de markt onder een koude stemming aantoont;</p>
<p>-Bitcoin daalde gisteravond onder de $60.000 en Altcoins volgden, waarbij Aptos, Base en Ton ketens als eerste weer opveerden.</p>
<h2 id="h2-Macroeconomie20De20Fed20heeft20geen20haast20om20de20rente20aanzienlijk20te20verlagen20focus20op20het20werkgelegenheidsrapport20van20vanavond134548"><a name="Macroeconomie: De Fed heeft geen haast om de rente aanzienlijk te verlagen, focus op het werkgelegenheidsrapport van vanavond" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De Fed heeft geen haast om de rente aanzienlijk te verlagen, focus op het werkgelegenheidsrapport van vanavond</h2><p>Federal Reserve-functionaris Goolsby zei gisteren dat de omvang van de renteverlagingen niet zo belangrijk is als een aanzienlijke verlaging van de neutrale rente in de komende 12 maanden. Ook Powell is van dezelfde mening en benadrukt voorzichtige renteverlagingen, maar het aankomende werkgelegenheidsrapport zal zijn geduld testen.</p>
<p>Met name op de kapitaalmarkt zijn de spanningen en het beleid in het Midden-Oosten toegenomen, waardoor beleggers zich zorgen maken. Gisteren daalden de drie belangrijkste Amerikaanse aandelenindices lichtjes, waarbij de VIX-volatiliteitsindex boven de 20 uitkwam. In reactie hierop steeg de Amerikaanse dollarindex naar een nieuw hoogtepunt voor de derde opeenvolgende dag, en stegen zowel de goud- als de olieprijzen.</p>
<p>Vanavond worden de gegevens van de niet-agrarische loonlijst vrijgegeven, en de markt verwacht over het algemeen een maand-op-maand toename van 150.000 mensen, waarbij de werkloosheid rond de 4,2% stabiliseert.</p>
<p>Over het algemeen zijn de marktverwachtingen agressiever dan die van de Federal Reserve, en men gelooft dat dit de Fed zal aanzetten om verdere losse beleidsmaatregelen te nemen.</p>
<h3 id="h3-Conclusie376760"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Te midden van de gespannen situatie in het Midden-Oosten en de onzekerheid van het rentebeleid van de Federal Reserve, zijn de zorgen van investeerders nog niet afgenomen en worden veilige havenactiva zoals goud gezocht. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> heeft een zekere mate van aanpassing ondergaan, waarbij BTC gisteren licht steeg na vier opeenvolgende dagen van daling, en de marktsentiment begon een positieve trend te ontwikkelen.</p>
<p>Ondanks de recente slechte prestaties van Bitcoin, waarbij een record wordt gevestigd voor de slechtste oktober in bijna een decennium, vond volgens de geschiedenis het grootste deel van de oktoberrally plaats na de 19e. Over het algemeen staat de cryptomarkt nog steeds voor kortetermijnaanpassingen, maar sommige hete sectoren hebben nog steeds een zeker welvaart genererend effect.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<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>