RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBzY2hvbW1lbGRlIGVuIHZpZWwsIG1hcmt0IHdhY2h0IG9wIGRlIENQSS1nZWdldmVucyB2YW4gdmFuYXZvbmQ=

2024-10-10, 04:28

<p><img src="https://gimg2.gateimg.com/image/article/172853427710.10.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20BTC20ETFs20ondervonden20opnieuw20nettouitstroom20Swell20opende20een20luchtdalingsonderzoek503328"><a name="Crypto Dagelijks Overzicht: BTC ETF’s ondervonden opnieuw nettouitstroom, Swell opende een luchtdalingsonderzoek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: BTC ETF’s ondervonden opnieuw nettouitstroom, Swell opende een luchtdalingsonderzoek</h2><p>Volgens Farside Investor-gegevens is er een nettostroom van Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gisteren bedroeg de handel in ETF’s $30,56 miljoen, waarvan $13,91 miljoen afkomstig was van IBIT en $44,47 miljoen van ARKB.</p>
<p>Gisteren was er een nettostroom vanuit/naar de Amerikaanse spotmarkt <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s was 0.</p>
<p><strong>Na de notulen van de Fed-vergadering is de kans op een renteverlaging van 25 basispunten in november gedaald tot 78%.</strong></p>
<p>Na de notulen van de vergadering van de Federal Reserve, volgens de gegevens van CME’s “FedWatch”, is de waarschijnlijkheid dat de Fed de rente in november met 25 basispunten verlaagt 78%, terwijl de waarschijnlijkheid dat de rente onveranderd blijft op 4,75% -5,00% is gestegen naar 22%.</p>
<p><strong>Meme munten vielen over het algemeen terug na een aanzienlijke stijging in de beginfase, terwijl MOODENG met meer dan 20% daalde</strong></p>
<p>Volgens on-chain marktgegevens zijn eerder stijgende meme-munten over het algemeen weer gedaald, met <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De MOODENG van ‘s daalt dagelijks met 22,6%, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> MOODENG van ‘s dagelijkse daling van 19,5% ervaren, Harry PotterObamaSonic10Inu van ‘s dagelijkse daling van 18,1% ervaren, en Sui’s meme coin BLUB van ‘s dagelijkse daling van 13,5% ervaren.</p>
<p><strong>Swell heeft de airdrop-query geopend, 7.500 adressen zijn geïdentificeerd als heksenadressen</strong></p>
<p>Swell, een liquiditeits herbeleggingsplatform, heeft de airdropquery geopend. De totale voorraad SWELL-tokens is 10 miljard, waarvan 8,5% (850 miljoen) zal worden gebruikt voor Voyage airdrops.</p>
<p>Wanneer de claim open is, worden 700 miljoen SWELs lineair verdeeld op basis van de opgebouwde White Pearls van elke Voyager. Daarnaast wordt 1,5% toegewezen aan gebruikers die hebben deelgenomen aan staking op basis van loyaliteitsbeloningsmethoden. Momenteel zijn 7500 walletadressen geïdentificeerd als heksadressen (in totaal meer dan 7,3 miljoen Pearls).</p>
<p>Het officiële statement vermeldt dat de SWELL-token doeleinden heeft zoals het betalen van gasvergoedingen, het besturen van Swell DAO, en het opnieuw inzetten om de beveiliging van Swell L2-toepassingen en infrastructuur te waarborgen.</p>
<h2 id="h2-Markttrends20BTC20zakte20weer20onder20de20wekelijkse20Bollinger20Bands20terwijl20Altcoins20over20het20algemeen20daalden389068"><a name="Markttrends: BTC zakte weer onder de wekelijkse Bollinger Bands, terwijl Altcoins over het algemeen daalden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC zakte weer onder de wekelijkse Bollinger Bands, terwijl Altcoins over het algemeen daalden</h2><h3 id="h3-Markt20hotspots629606"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>De fan token CHZ is gestegen, en de officiële aankondiging is dat ze de meme coin PEPPER zullen airdroppen naar CHZ-houders. Ondanks de stimulatie van het nieuws zijn de contractfinancieringspercentages van CHZ hoog en zijn er veel verkopers op korte termijn. Momenteel is er marktdivergentie in de prijs van CHZ;</p>
<p>De prijzen van NEIROCTO en BABYDOGE in de Meme-sector stegen, waarbij NEIROCTO de toonaangevende token is in marktsentiment;</p>
<p>PROS is gestegen en er gaan geruchten in de gemeenschap dat investeringsmaatschappij Animoca Brands zijn belang heeft vergroot.</p>
<h3 id="h3-Mainstream20Munten278841"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC schommelde en daalde, momenteel handelend op $60.650, en viel terug onder de wekelijkse Bollinger Bands. Korte termijn marktaanpassingen zijn onvermijdelijk;</p>
<p>ETH zakte terug onder de $2.400, en op het nieuwsfront begon PlusToken’s eerder in beslag genomen 1,3 miljard ETH te verminderen, wat de belangrijkste reden kan zijn voor de slechte prestaties van de ETH-markt;</p>
<p>Altcoins dalen over het algemeen en de markt wacht op de vrijgave van CPI-gegevens.</p>
<h2 id="h2-Macroeconomie20Amerikaanse20aandelen20stegen20gezamenlijk20SampP2050020bereikte20intraday20recordhoogte273169"><a name="Macroeconomie: Amerikaanse aandelen stegen gezamenlijk, S&amp;P 500 bereikte intraday recordhoogte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: Amerikaanse aandelen stegen gezamenlijk, S&amp;P 500 bereikte intraday recordhoogte</h2><p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de S&amp;P 500-index met 0,71% steeg tot 5.792,04 punten; de Dow Jones Industrial Average steeg met 1,03% tot 42.512,00 punten; de Nasdaq-index steeg met 0,60% tot 18.291,62 punten. Het referentiepunt van de 10-jaarsrente bedraagt 4,06%, terwijl de 2-jaarsrente, die het meest gevoelig is voor het rentebeleid van de Federal Reserve, 3,99% bedraagt.</p>
<p>De Federal Reserve’s Daley verklaarde: ‘We ondersteunen volledig een renteverlaging van 50 basispunten in september en hebben vertrouwen in het traject naar het bereiken van het 2% inflatiedoel en hebben volledige werkgelegenheid bereikt.’ De Federal Reserve zal de rente 1-2 keer verlagen gedurende de resterende tijd van dit jaar; Stabiele beleidsrente en stijgende reële rentevoeten. Bovendien zal de Fed zich richten op gegevens, de arbeidsmarkt en inflatie volgen en de rentevoeten aanpassen indien nodig; De omvang van de renteverlaging in september betekent niet noodzakelijk de snelheid of omvang van toekomstige renteverlagingen.</p>
<h3 id="h3-Conclusie699154"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>De recente smalle consolidatie van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> duidt op voorzichtige marktsentiment. Functionarissen van de Federal Reserve hebben aangegeven dat renteverlagingen afhankelijk zijn van gegevens, wat aangeeft dat toekomstig beleid voorzichtiger zal zijn en invloed kan hebben op de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> van fondsen in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>. Ondertussen, ondanks de voortdurende daling van de inkomsten van Bitcoin-mijnwerkers, hebben portefeuilles die meer dan 10.000 BTC bevatten hun holdings aanzienlijk verhoogd, wat prijsondersteuning kan bieden. Op de markt hebben opkomende meme-munten zoals NEIROCTO sterk gepresteerd, wat het risicobereidheid van beleggers weerspiegelt. Met de komende lancering van projecten zoals Scroll kan de markt op korte termijn nieuwe stimulatie ervaren, maar de algehele markt fluctueert nog steeds en wacht op richting.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijsing</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 investeringssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>