RGFnZWxpamtzIE5pZXV3cyB8IE5vbi1mYXJtIFBheXJvbGwgRGF0YSBIZXJzdGVsZGUgWmljaCwgRGUgRGFsaW5nIHZhbiBCVEMgVmVybmF1d2RlIGVuIFN0YWJpbGlzZWVyZGUgb3AgJDYwLjAwMA==

2024-10-03, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/172792733510.3.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20hadden20nettouitstromen20van20ongeveer209220miljoen20ETH20ETFs20hadden20nettostromen20van20bijna2020320miljoen905560"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s hadden netto-uitstromen van ongeveer $92 miljoen, ETH ETF’s hadden nettostromen van bijna $20,3 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s hadden netto-uitstromen van ongeveer $92 miljoen, ETH ETF’s hadden nettostromen van bijna $20,3 miljoen</h2><p>Volgens Trader T monitoring gegevens, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF had gisteren een netto uitstroom van $92,03 miljoen, terwijl de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had gisteren een nettostroom van $20,35 miljoen.</p>
<p><strong>De inkomsten van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> miners daalden tot ongeveer $815 miljoen in september, terwijl de inkomsten uit Ethereum-staking daalden tot ongeveer $200 miljoen.</strong></p>
<p>Volgens gegevens van The Block Pro daalde de omzet van Bitcoin-miners in september verder tot $815,3 miljoen, een daling van 4,2%. Bovendien daalde ook de Ethereum-stakingsomzet met 4% tot $209,4 miljoen. In september vernietigde het Ethereum-netwerk bovendien in totaal 26874 ETH ter waarde van $68,2 miljoen.</p>
<p><strong>De waarschijnlijkheid dat de Fed de rente met 25BP verlaagt in november is 62,8%</strong></p>
<p>Volgens CME’s ‘FedWatch’ is de waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten zal verlagen tegen november 62,8%, en de waarschijnlijkheid dat de rente met 50 basispunten zal worden verlaagd 37,2%. De waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten tegen december is 36,8%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 75 basispunten is 47,8%; De waarschijnlijkheid van een cumulatieve renteverlaging van 100 basispunten is 15,7%.</p>
<p><strong>SEC gaat in beroep tegen de uitspraak in de Ripple-zaak</strong></p>
<p>Volgens The Block gaat de Amerikaanse Securities and Exchange Commission (SEC) in beroep tegen de eerdere uitspraak van het Amerikaanse Hof van Beroep voor het Tweede Circuit tegen de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Betalingsbedrijf Ripple. Bovendien verklaarde de Chief Legal Officer van Ripple dat ze ueren of ze een tegenclaim moeten indienen tegen de Amerikaanse SEC.</p>
<p><strong>Japan zal de regelgeving voor cryptocurrency ueren, mogelijk met het oog op het creëren van voorwaarden voor de lancering van crypto ETF’s</strong></p>
<p>Volgens rapporten is Japan van plan om de effectiviteit van zijn crypto-regelgeving te ueren, die in de komende maanden zal plaatsvinden en de weg kan vrijmaken voor het land om crypto exchange traded funds (ETF’s) te lanceren.</p>
<p><strong>Abu Dhabi heeft een voorgesteld regelgevend kader voor fiat-referentiemunten en heeft openbaar meningen gevraagd</strong></p>
<p>De financiële toezichthoudende instantie van Abu Dhabi heeft plannen om de fiat-referentietoken (FRT) te reguleren en heeft het publiek uitgenodigd om feedback te geven over het voorgestelde regelgevingskader. De Financial Services Regulatory Authority (FSRA) van de Abu Dhabi Global Market heeft 3 oktober 2024 vastgesteld als deadline voor het geven van commentaar op het voorstel.</p>
<h2 id="h2-Markttrends20de20daling20van20BTC20is20afgenomen20en20gestabiliseerd20op206000020met20lokale20hotspots20die20opduiken20op20de20markt808400"><a name="Markttrends: de daling van BTC is afgenomen en gestabiliseerd op $60.000, met lokale hotspots die opduiken op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de daling van BTC is afgenomen en gestabiliseerd op $60.000, met lokale hotspots die opduiken op de markt</h2><h3 id="h3-Markt20Hotspots376788"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>-Het high-performance Layer1 openbare keten token SUI blijft een opwaartse trend behouden, met de prijs die vanochtend $2 heeft doorbroken en een stijging van bijna 9% in 24 uur. De circulerende marktwaarde heeft $5,4 miljard bereikt en staat op het punt om de marktwaarde van $5,7 miljard te overschrijden <a href="/price/near-protocol-near" rel="nofollow noopener noreferrer" target="_blank">NEAR Protocol</a>(NEAR), dat er dicht achter zit.</p>
<p>-Verschillende beurzen, waaronder Gate.io, lanceerden gisteren DIA eeuwigdurende contracten. DIA is een <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> cross-chain, open-source data en oracle platform dat onlangs Lumina lanceerde, een oracle stack die Rollup ondersteunt. Hierna zal het een testnetwerk lanceren en een uitgebreide mainnet-implementatie en netwerkuitbreiding uitvoeren.</p>
<p>-Dankzij de lancering van spot trading op de Koreaanse beurs steeg Wormhole (W) tegen de trend in, met een stijging van 10% in 24 uur en een totale marktwaarde van $3,488 miljard. Wormhole is een oplossing die multi chain communicatie ondersteunt en zich heeft ontwikkeld tot een universeel berichtenprotocol. Het is een van de drie trending protocollen op het gebied van chain abstractie.</p>
<h3 id="h3-Mainstream20Munten861346"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>-BTC is de afgelopen 4 opeenvolgende dagen gedaald, waardoor tijdelijk de impact van spanningen in het Midden-Oosten is verminderd. Hoewel het gisteren steeg en daalde, is het op technisch niveau nog niet bearish geworden. Het ondersteuningseffect van het gehele niveau van $60000 is duidelijk, en investeerders moeten het doorbraaksignaal na het opbouwen van momentum in de gaten houden;</p>
<p>-ETH is al 5 opeenvolgende dagen gedaald, met een daling van 4,06% in 24 uur. Op basis van gegevens zoals een daling van 22% in NFT-handelsvolume en een daling van 4% in stakinginkomen in september, zijn de fundamenten van ETH inderdaad niet verbeterd;</p>
<p>-Naarmate de daling van Bitcoin afneemt, is er een lokale opwaartse trend in Altcoins, aangevoerd door de Meme, Gambling en SUI-ecosysteemsectoren. SUI, POPCAT, DOGS, DEGEN, MANTA en andere sectoren worden allemaal begunstigd door fondsen, met indrukwekkende winsten.</p>
<h2 id="h2-Macroeconomie20gegevens20over20nietagrarische20lonen20herstelden20zich20de20cryptomarkt20bevindt20zich20nog20steeds20in20een20aanpassingstrend222946"><a name="Macroeconomie: gegevens over niet-agrarische lonen herstelden zich, de cryptomarkt bevindt zich nog steeds in een aanpassingstrend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: gegevens over niet-agrarische lonen herstelden zich, de cryptomarkt bevindt zich nog steeds in een aanpassingstrend</h2><p>Recentelijk, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> heeft meerdere verstoringen meegemaakt, waarbij de spanningen in het Midden-Oosten lichtjes afnemen en de impact op de markt afneemt.</p>
<p>De Amerikaanse president Biden kondigde sancties aan tegen Iran, terwijl Israël dreigde met een grote vergeldingsactie tegen Iran, gericht op haar olieproductiefaciliteiten. Deze reeks geopolitieke risico’s heeft geleid tot een wijdverbreide verkoop van risicovolle activa en aanzienlijk verhoogde marktvolatiliteit.</p>
<p>Echter, tegen de achtergrond van wereldwijde centrale banken die een cyclus van renteverlagingen ingaan, zullen dergelijke tegenslagen een relatief kortdurende impact hebben op de markt. Het gisteren in de Verenigde Staten vrijgegeven ADP-rapport toonde een herstel op de arbeidsmarkt, waarbij de werkgelegenheid in alle sectoren toenam, behalve in de informatiesector, en positieve gegevens voor kleine en niet-agrarische sectoren. Na de opening van de Amerikaanse aandelenmarkt daalden de S&amp;P 500-index en de Nasdaq-index lichtjes, en ook de aandelen van cryptoconcepten daalden.</p>
<p>Federal Reserve-functionaris Barkin verklaarde echter dat de renteverlaging van 0,5 procent in september in overeenstemming is met de huidige economische omgeving, aangezien het renteniveau niet overeenkomt met de neerwaartse trend in inflatie- en werkloosheidscijfers, wat verder van invloed is op het marktsentiment en de korte termijn prestaties van de cryptomarkt.</p>
<p>Met de achtergrond van een opleving in kleine niet-agrarische payroll-gegevens en de voortdurende situatie in het Midden-Oosten, verkeert de crypto-markt nog steeds in een staat van aanpassing.</p>
<h3 id="h3-Conclusie93077"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Hoewel BTC al 4 opeenvolgende dagen daalt, is de impact van spanningen in het Midden-Oosten afgezwakt en heeft de $60.000 mark ondersteuning geboden. De markt kijkt uit naar signalen van een doorbraak.</p>
<p>Uit meerdere gegevensbronnen blijkt dat het nieuwe walvissenadres een grote hoeveelheid BTC aan het opslaan is, en dit zeldzame bewaarpatroon heeft niet veel te maken met ETF-inflows. Hoewel de prijzen nog steeds dalen, kan dit een tijdelijk fenomeen zijn en geen voorbode van een langdurige berenmarkt.</p>
<p>In de komende maanden wordt verwacht dat Bitcoin zal profiteren van gebeurtenissen zoals de renteverlagingen van de Federal Reserve, het einde van het Amerikaanse verkiezingsseizoen en de terugkeer van gelden uit spot ETF’s.</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 visie van de onderzoeker en vormt geen beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>