RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYncyBzdHJvb21kZW4gb3Agw6nDqW4gZGFnIHZvb3IgbWVlciBkYW4gJDU1MCBtaWxqb2VuIGJpbm5lbiwgZW4gb3ZlciBoZXQgYWxnZW1lZW4gc3RlZ2VuIGFsdGNvaW5zIG9wIGRlIG1hcmt0

2024-10-15, 04:42

<p><img src="https://gimg2.gateimg.com/image/article/172896723910.15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20kenden20een20nettostroom20van2055020miljoen20op20n20dag20Sui20reageerde20op20verkoopbeschuldigingen278383"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s kenden een nettostroom van $550 miljoen op één dag, Sui reageerde op verkoopbeschuldigingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s kenden een nettostroom van $550 miljoen op één dag, Sui reageerde op verkoopbeschuldigingen</h2><p>Volgens Farside Investor-gegevens was er gisteren een nettostroom naar Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> ETF’s was $551 miljoen, inclusief $79 miljoen van BlackRock IBIT, $239 miljoen van Fidelity FBTC, $69,8 miljoen van ARKB, en $100 miljoen van Bitwise BITB.</p>
<p>Gisteren was de algehele instroom en uitstroom van fondsen in de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s waren relatief klein, slechts in miljoenen dollars. In vergelijking met het handelsvolume en de kapitaalinstroom van BTC ETF’s is de prestatie van ETH ETF’s ver onder de verwachtingen gebleven.</p>
<p><strong>De totale marktkapitalisatie van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> herstelde zich en overschreed $2,4 biljoen</strong></p>
<p>Volgens CoinGecko-gegevens is de totale marktkapitalisatie van cryptocurrencies hersteld en overschrijdt deze $2,4 biljoen, nu wordt er gerapporteerd $2,403 biljoen, met een stijging van 3,8% in 24 uur. BTC keerde vanochtend vroeg terug boven $66.000 en ETH steeg boven $2.600, wat wijst op een algemene stijging in het geheel. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> De gemeenschap gelooft dat het imitatie seizoen is aangebroken.</p>
<p><strong>Sui Foundation reageerde op interne beschuldigingen van de verkoop van $400 miljoen aan tokens: er is geen sprake geweest van voorafgaande verkoop of schending van lock-up plannen</strong></p>
<p>De Sui Foundation heeft gereageerd op de beschuldiging dat ‘Sui insiders tijdens de opwaartse trend tokens ter waarde van $400 miljoen hebben verkocht’, en heeft verklaard dat de Sui Foundation hoopt deze persoon rechtstreeks te kunnen antwoorden:</p>
<p>Geen insiders, inclusief medewerkers van de stichting of Mysten Labs (inclusief de oprichter van Mysten Labs) en investeerders in ML, hebben tokens ter waarde van $400 miljoen verkocht tijdens de stijgende trend, zowel individueel als in combinatie. Insiders hebben zich niet beziggehouden met enige preventieve verkoop of hebben de lock-up- en circulatieaanbodplannen overtreden.</p>
<p>Hoewel de poster geen portefeuilleadres heeft verstrekt, is de Sui Foundation van mening dat de potentiële portefeuille-eigenaar een infrastructuurpartner is die tokens bezit en een lock-up plan volgt. Alle token lock-ups worden uitgevoerd door gekwalificeerde bewaarders en continu gemonitord door de Sui Foundation, en de activiteiten van deze partner zijn in overeenstemming.</p>
<p><strong>Analist: BTC verkoopdruk verminderd, maar de markt blijft in een passieve staat</strong></p>
<p>Het analyseverslag wijst erop dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ervoer vorige week een aanzienlijke terugval, gedreven door een grote verkoopgolf in de spotprijzen, die meer dan 11% daalde van zijn hoogtepunt van $66.587 eind september tot zijn laagtepunt van $58.943 op 10 oktober. De verkoopdruk nam echter enigszins af en BTC herstelde zich snel. On-chain indicatoren benadrukken het belang van de werkelijke prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op korte termijn (momenteel dicht bij $63.000) als een belangrijk weerstandsniveau. Het doorbreken van dit niveau kan wijzen op verdere bullish momentum, terwijl het niet doorbreken van dit niveau kan leiden tot het opnieuw testen van lagere steunniveaus, mogelijk dicht bij $59.000 of zelfs $55.000.</p>
<p>Echter gelooft het rapport ook dat de markt nog steeds passief is en toekomstige trends afhankelijk kunnen zijn van of Bitcoin beslissend kan overstijgen de realisatieprijs van kortetermijnhouders. Voordat dit gebeurt, moeten handelaren rekening houden met een mogelijke terugval en voorbereid zijn op een sterkere opleving van lagere niveaus, omdat de markt potentieel veerkracht heeft. Bovendien heeft de beheerder van Mt. Gox, vanwege programmadiscrepanties, de vervaldatum voor het terugbetalen van crediteuren verlengd tot 31 oktober 2025. Deze verlenging heeft de marktzorgen over een mogelijke verkoop van Bitcoin verlicht, aangezien veel mensen zich zorgen maken dat crediteuren een deel van de 44.900 BTC kunnen liquideren die binnenkort zal worden verdeeld, wat druk kan uitoefenen op de Bitcoin-prijzen.</p>
<h2 id="h2-Markttrends20BOME20steeg20met20meer20dan203020REEF20steeg20en20viel20terug483630"><a name="Markttrends: BOME steeg met meer dan 30%, REEF steeg en viel terug" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BOME steeg met meer dan 30%, REEF steeg en viel terug</h2><h3 id="h3-Markt20Hotspots469820"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De Meme-sector kende een collectieve stijging in BOME, MANKEI, TURBO en andere valuta’s, waarbij alle circulerende valuta’s meer in trek waren bij marktspeculatiefondsen. TURBO is de paddentoken van het AI-concept; MANEKI is een meme-munt met de afbeelding van een financiële kat op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain. Beïnvloed door de marktkapitalisatie van POPCAT die de $1 miljard overstijgt, heeft MANEKI zich geleidelijk hersteld van de neerwaartse trend;</p>
<p>De stijging van SOL heeft de opkomst van veroorzaakt. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteemprojecten zoals JTO en RAY. Het meme-project op de Solana-keten wordt actief verhandeld, met een snelle transactiesnelheid en lage transactiekosten, waardoor het populairder is op de markt;</p>
<p>REEF steeg 40% op één dag, steeg toen en viel terug. REEF is vergelijkbaar met de demon-valuta TRB in oktober 2023, die blijft stijgen en kort blijft duwen, met contracttarieven die hoog blijven.</p>
<h3 id="h3-Gangbare20Munten688321"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC brak door het volatiele bereik en keerde terug boven $66.000. Gisteren zag BTC ETF een dagelijkse instroom van meer dan $500 miljoen, wat de grootste dagelijkse instroom sinds maart is;</p>
<p>EHT volgde de stijging en brak door $2,600, een algehele stijging iets kleiner dan andere openbare ketentokens op de markt. ETH ETF’s kregen geen grote instroom zoals BTC ETF’s;</p>
<p>Altcoins stegen over het algemeen, en vroege sterke valuta’s zoals REEF en POPCAT kwamen als eerste in het aanpassingsbereik, wat wijst op de komst van het Altcoin-seizoen.</p>
<h2 id="h2-Macroeconomie20De20drie20belangrijkste20Amerikaanse20aandelenindices20sloten20gezamenlijk20hoger20waarbij20de20SampP2050020en20de20Dow20Jones20Industrial20Average20nieuwe20historische20hoogtepunten20bereikten692149"><a name="Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de S&amp;P 500 en de Dow Jones Industrial Average nieuwe historische hoogtepunten bereikten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de S&amp;P 500 en de Dow Jones Industrial Average nieuwe historische hoogtepunten bereikten</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten collectief hoger, waarbij de Nasdaq met 0,87% steeg, de S&amp;P 500-index met 0,77% steeg en de Dow Jones Industrial Average met 0,47% steeg. Onder hen bereikten de S&amp;P 500-index en de Dow Jones Industrial Average nieuwe historische hoogtepunten, terwijl de Nasdaq een nieuw hoogtepunt bereikte in ongeveer drie maanden. De meeste grote technologie-aandelen zijn gestegen, waarbij Nvidia met meer dan 2% steeg om een historisch hoogtepunt te bereiken; Apple en Google stegen met meer dan 1%, terwijl Microsoft, Tesla en Meta lichte stijgingen zagen; Netflix daalde met meer dan 1%, terwijl Amazon een lichte daling kende. Trump-conceptaandelen namen aanzienlijk toe, waarbij Trump Media Technology Group meer dan 18% steeg.</p>
<p>Vroeg in de ochtend, Beijing tijd, heeft Federal Reserve Governor Waller tijdens een bijeenkomst aan de Stanford University zijn laatste mening gegeven over de verwachtingen voor een renteverlaging in de toekomst. Hij is van mening dat toekomstige renteverlagingen ‘voorzichtiger’ moeten zijn, wat impliceert dat de omvang van toekomstige renteverlagingen kleiner zal zijn dan de significante renteverlaging in september.</p>
<p>Waller haalde recente rapporten aan over werkgelegenheid, inflatie, BBP en inkomen, waarbij hij opmerkte dat de economie mogelijk niet zo sterk is afgezwakt als verwacht, en veel sterker is dan eerder gedacht, met weinig tekenen van een significante vertraging in de economische activiteit. Hij zei dat de huidige economische gegevens de Federal Reserve in staat stellen om de rentetarieven op een ‘passend tempo’ te verlagen totdat een neutraal tarief is bereikt.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>