RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBiZXJlaWt0IG5pZXV3ZSBob29ndGVwdW50ZW4gbmEgZGUgdmVya2llemluZ3NvdmVyd2lubmluZyB2YW4gVHJ1bXAsIGRlIEFtZXJpa2FhbnNlIGFhbmRlbGVubWFya3QgYmVoYWFsdCBkZSBiZXN0ZSBwcmVzdGF0aWUgbmEgZGUgdmVya2llemluZ2VuIGluIGRlIGdlc2NoaWVkZW5pcw==

2024-11-07, 04:39

<p><img src="https://gimg2.gateimg.com/image/article/173095379811.07.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20BTC20ETFs20hervatten20grote20instroom20met20meer20dan2014000020mensen20die20posities20verkopen20over20het20hele20netwerk20in20de20afgelopen202420uur98152"><a name="Crypto Dagelijks Overzicht: BTC ETF’s hervatten grote instroom, met meer dan 140.000 mensen die posities verkopen over het hele netwerk in de afgelopen 24 uur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: BTC ETF’s hervatten grote instroom, met meer dan 140.000 mensen die posities verkopen over het hele netwerk in de afgelopen 24 uur</h2><p>Volgens Farside Investor-gegevens is de netto instroom van de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De handel in ETF’s op de spotmarkt bedroeg gisteren $622 miljoen, inclusief een nettostroom van $68,31 miljoen uit IBIT, $308,77 miljoen uit FBTC en $127 miljoen uit ARKB.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s ontvingen $52.3 miljoen aan instroom, waaronder $26.9 miljoen van Fidelity FETH en $25.4 miljoen van Grayscale ETH.</p>
<p><strong>In de afgelopen 24 uur heeft het hele netwerk een voorraadexplosie van $613 miljoen meegemaakt, met meer dan 140.000 mensen die posities verkopen</strong></p>
<p>Volgens Coinglass-gegevens is er in de afgelopen 24 uur in totaal $613 miljoen aan online liquidatie geweest, inclusief $428 miljoen aan shortposities. Daarnaast zijn er in de afgelopen 24 uur in totaal 142.735 mensen geliquideerd, waarbij de grootste enkele geliquideerde order ter waarde van $74.9828 miljoen was.</p>
<p><strong>De Amerikaanse aandelenmarkt heeft de beste prestaties na de verkiezingen ooit behaald, met crypto-aandelen als koploper in de winst.</strong></p>
<p>Volgens marktinformatie heeft de Amerikaanse aandelenmarkt de beste prestatie na de verkiezingen in de geschiedenis geleverd, met de S&amp;P 500-index die rond de 5.930 punten zweeft en zijn 48e historische hoogtepunt sinds het begin van het jaar bereikt. De Nasdaq 100-index steeg met 2,7%, wat voor het eerst sinds juli een record vestigde. De Dow Jones Industrial Average steeg met 3,6%.</p>
<p>Daarnaast hebben crypto-conceptaandelen een uitstekende prestatie laten zien, met een stijging van 13,17% voor MicroStrategy, 31,11% voor Coinbase en 14,75% voor Tesla. Het is vermeldenswaardig dat de Trump Media Technology Group (DJT) steeg maar weer daalde, met een slotstijging van slechts 5,94%.</p>
<p><strong>Als BTC onder de $72.000 zakt, zal de cumulatieve liquidatiesterkte van mainstream CEX-orders 1,777 miljard bereiken</strong></p>
<p>Volgens Coinglass-gegevens, als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zakt onder de $72.000, dan zal de cumulatieve liquidatiesterkte van mainstream CEX-orders 1,777 miljard bereiken. Als daarentegen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Wanneer de prijs $75.000 doorbreekt, zal de cumulatieve liquidatiekracht van mainstream CEX short orders 339 miljoen bereiken.</p>
<p>Het liquidatieoverzicht toont in hoeverre de doelprijs zal worden beïnvloed wanneer deze een bepaalde positie bereikt. Een hogere ‘liquidatiekolom’ geeft aan dat de prijs een sterkere reactie zal hebben vanwege de golf van liquiditeit zodra deze aankomt.</p>
<h2 id="h2-Markttrends20BTC20bereikte20een20nieuw20historisch20hoogtepunt20waarbij20PNUT20NEIRCTO20en20anderen20aanzienlijke20winsten20boekten779237"><a name="Markttrends: BTC bereikte een nieuw historisch hoogtepunt, waarbij PNUT, NEIRCTO en anderen aanzienlijke winsten boekten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bereikte een nieuw historisch hoogtepunt, waarbij PNUT, NEIRCTO en anderen aanzienlijke winsten boekten</h2><h3 id="h3-Markthoogtepunten880860"><a name="Markthoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten</h3><p>De Meme sector heeft een aanzienlijke toename gezien in PNUT, NEIROCTO, MOODENG, LUCE, onder andere. PNUT is herhaaldelijk genoemd door Musk op Twitter, alsof hij de schaduw van FLOKI uit de vorige bullmarkt zag, die ook meerdere keren door Musk werd genoemd. Na een scherpe stijging kende de gevestigde meme-leider DOGE een lichte daling, waarbij fondsen overstroomden naar andere kleine marktmemes zoals NEIROCTO, die met 50% steeg en momenteel een circulerende marktwaarde heeft van meer dan $900 miljoen;</p>
<p>De goed gevestigde DeFi-tokens UNI, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a>, LDO, ENA, enz. zijn enorm gestegen, profiterend van de campagnebelofte van Trump vóór zijn verkiezing als president van de VS om SEC-voorzitter Powell te ontslaan, die voorheen onvriendelijk was voor cryptocurrencies. In de mogelijk meer ontspannen regelgevingsomgeving zijn gevestigde DeFi-protocollen zoals UNI en <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> kan protocol inkomsten uitkeren aan tokenhouders, waardoor de markt vertrouwen krijgt met dividendverwachtingen;</p>
<p>Politieke memes met betrekking tot de Amerikaanse presidentsverkiezingen, zoals MAGA, TRUMP, FIGHT, etc., hebben een scherpe daling meegemaakt en de markt is niet zoals verwacht. Als Trump wordt gekozen, zullen deze tokens meer steun krijgen van fondsen. Memes gerelateerd aan het concept van Trump en het concept van Harris zijn ook sterk gedaald. Na bevestiging van de verkiezingsuitslagen kan worden gezien als het voltooien van de verwachte politieke meme-hype hierboven genoemd, en er zullen geen verdere gerelateerde onderwerpen zijn in de markt.</p>
<h3 id="h3-Mainstream20munten3716"><a name="Mainstream munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream munten</h3><p>BTC bereikte een nieuwe historische piek, op een gegeven moment meer dan $76.000 doorbrekend. De BTC ETF’s zagen een enorme dagelijkse instroom, en Trump’s verkiezing als president van de Verenigde Staten gaf de markt veel vertrouwen;</p>
<p>ETH steeg met 10%, en met verwachtingen van een beter macro-economisch klimaat, kregen ETH ETF’s ook aanzienlijke instromen van fondsen, wat de ETH-prijzen stimuleerde;</p>
<p>Altcoins stijgen over het algemeen, waarbij nieuwe meme-munten zoals GOAT en NEIROCTO de markttrend leiden.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20stijgen20over20de20hele20linie20waarbij20de20Fed20vrijwel20zeker20de20rente20met202520basispunten20zal20verlagen568531"><a name="Macro nieuws: Amerikaanse aandelen stijgen over de hele linie, waarbij de Fed vrijwel zeker de rente met 25 basispunten zal verlagen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen stijgen over de hele linie, waarbij de Fed vrijwel zeker de rente met 25 basispunten zal verlagen.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt zijn allemaal gestegen, waarbij de S&amp;P 500-index met 2,53% stijgt naar 5.929,04 punten; De Dow Jones Industrial Average steeg met 3,57% naar 43.729,93 punten; De Nasdaq-index steeg met 2,95% naar 18.983,46 punten. Het benchmark 10-jaars rendement op schatkistpapier bedraagt 4,42%, terwijl het 2-jaars rendement op schatkistpapier, dat het meest gevoelig is voor het rentebeleid van de Federal Reserve, 4,27% bedraagt.</p>
<p>Trump kondigde zijn verkiezing aan als de nieuwe president van de Verenigde Staten, die tijdens zijn ambtstermijn mogelijk een meer ontspannen economische omgeving heeft. De Amerikaanse aandelenmarkt steeg over de hele linie, waarbij de drie belangrijkste aandelenindices allemaal met meer dan 2% stegen en de Nasdaq zelfs met meer dan 3,5% steeg. Beïnvloed door de Amerikaanse presidentsverkiezingen en de wintertijd zal de Federal Reserve zijn rentebesluit bekendmaken om 03:00 uur Beijing-tijd op vrijdag 8 november. Marktgegevens wijzen erop dat de 25 basispunten renteverlaging van de Fed vrijwel zeker is.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Glazuur</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 beleggingssuggestie. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel te delen mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>