RGFnZWxpamtzIG5pZXV3cyB8IEZlZCBrb25kaWdkZSBlZW4gcmVudGV2ZXJsYWdpbmcgdmFuIDUwIGJhc2lzcHVudGVuIGFhbiwgQlRDIGxlaWRkZSBkZSBhbGdlaGVsZSBjcnlwdG8tbWFya3Qgb20gYWFuemllbmxpamsgdGUgaGVyc3RlbGxlbg==

2024-09-19, 04:36

<p><img src="https://gimg2.gateimg.com/image/article/17267204499.19.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Als20Bitcoin20doorbreekt206400020zal20de20gecumuleerde20short20clearing20kracht20van20de20mainstream20CEXs2054020miljoen20bereiken780735"><a name="Crypto Dagelijkse Samenvatting: Als Bitcoin doorbreekt $64000, zal de gecumuleerde short clearing kracht van de mainstream CEX’s 540 miljoen bereiken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Als <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> doorbreekt $64000, zal de gecumuleerde short clearing kracht van de mainstream CEX’s 540 miljoen bereiken</h2><p>Volgens Farside Investor-gegevens, de Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF had gisteren een nettostroom van $52,83 miljoen, inclusief een nettostroom van $8,13 miljoen van GBTC en $43,41 miljoen van ARKB. BlackRock IBIT heeft geen instroom of uitstroom van fondsen.</p>
<p>De VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had gisteren een netto-uitstroom van $9,71 miljoen, met een uitstroom van $14,7 miljoen voor Grayscale ETF en een netto instroom van $4,95 miljoen voor BlackRock ETF.</p>
<p><strong>Gegevens: Als Bitcoin de $64000 doorbreekt, zal de gecumuleerde short clearing kracht van de mainstream CEX 540 miljoen bereiken.</strong></p>
<p>Volgens Coinglass-gegevens zal de cumulatieve short clearing-kracht van mainstream CEX’s 540 miljoen bereiken als Bitcoin door $ 64.000 breekt. Als daarentegen Bitcoin onder de $ 60.000 daalt, zal de cumulatieve liquidatiekracht van mainstream CEX-orders 708 miljoen bereiken.</p>
<p>De liquidatiegrafiek 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 als gevolg van de golf van liquiditeit zodra deze aankomt.</p>
<p><strong>BlackRock heeft een whitepaper uitgebracht waarin de positie van Bitcoin als een unieke vermogensklasse wordt beschreven.</strong></p>
<p>BlackRock, ‘s werelds grootste vermogensbeheerder, heeft onlangs een whitepaper van 9 pagina’s uitgebracht waarin de unieke positie van Bitcoin als belangrijke vermogensklasse wordt beschreven.</p>
<p>Het witboek wijst erop dat Bitcoin niet alleen een ‘uniek diversificatietool’ is, maar ook moeilijk te ueren is met behulp van traditionele analysemethoden voor activa. BlackRock benadrukt dat Bitcoin ‘bijna onaangetast is door macro-economische factoren die de meeste traditionele beleggingscategorieën beïnvloeden’, waardoor de prestaties en prijsvoorspellingen uitdagend zijn. Hoewel Bitcoin nog steeds wordt beschouwd als een ‘hoogrisico’-activum, heeft het beter gepresteerd dan alle andere belangrijke beleggingscategorieën in 7 van de afgelopen 10 jaar.</p>
<p>BlackRock is van mening dat de volatiliteit van Bitcoin-prijzen gedeeltelijk het evoluerende perspectief als alternatieve wereldmunt weerspiegelt. In het witboek wordt ook vermeld dat vanwege de schijnbare onafhankelijkheid van Bitcoin van wereldwijde macrofactoren, sommige beleggers het beschouwen als een optie voor ‘veilige haven’ in geopolitieke spanningen.</p>
<p><strong>De laatste keer dat de Fed de rente met 50 basispunten verlaagde was in maart 2020, en sindsdien is de Bitcoin meer dan tien keer gestegen</strong></p>
<p>Volgens statistieken was de laatste keer dat de Federal Reserve de rente met 50 basispunten verlaagde in maart 2020, toen het de rente met 1 procentpunt verlaagde naar 0-0,25% als reactie op de COVID-19-epidemie. Sinds maart 2022 heeft de Federal Reserve een bijna ongekende agressieve renteverhoging gelanceerd en heeft het de beleidsrente op een hoog niveau van 5,25% -5,5% gehouden sinds juli 2023.</p>
<p>Na de renteverlaging in 2020 begon Bitcoin te stijgen van de prijsklasse van $ 4.000 tot $ 6.000 na ‘3.12’, en bereikte het de piek van de vorige bullmarkt op $ 69040 in november 2021, met een maximale stijging van meer dan 10 keer.</p>
<p>Gedurende dezelfde periode begon de goudprijs te stijgen in het bereik van $1.450 tot $1.700 in maart, wat eerder de piek van Bitcoin overtrof. Na een hoogtepunt van $2.075 te hebben bereikt in augustus 2020, viel het terug en begon het een nieuwe ronde van opwaartse trend na een dieptepunt van $1.616 te hebben bereikt in november 2022.</p>
<h2 id="h2-Markttrends20BTC20leidde20de20markt20naar20een20aanzienlijk20herstel20terwijl20SUI20FTM20en20anderen20het20goed20deden157337"><a name="Markttrends: BTC leidde de markt naar een aanzienlijk herstel, terwijl SUI, FTM en anderen het goed deden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC leidde de markt naar een aanzienlijk herstel, terwijl SUI, FTM en anderen het goed deden</h2><h3 id="h3-Mainstream20Munten984656"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC keerde terug boven de $62.000 na de beslissing van de Federal Reserve om vandaag de rente met 50 basispunten te verlagen, wat leidt tot het algemene <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> aanzienlijk te herstellen;</p>
<p>ETH is teruggekeerd naar $2.400, maar de stijging is nog steeds relatief klein in vergelijking met andere openbare blockchainprojecten. De zwakte van ETH ETF wordt direct weerspiegeld in de prijs van ETH;</p>
<p>Altcoins zijn aanzienlijk hersteld en openbare ketenprojecten zoals SUI en FTM zijn gestegen;</p>
<p>Qua gegevensindicatoren stond de AHR999-index vandaag op 0,68, wat aangeeft dat de huidige <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC prijs</a> is nog steeds geschikt voor langdurige vaste investeringen; De Fear &amp; Greed Index staat op 49, wat wijst op een aanzienlijke verbetering op de markt na de rentevergadering.</p>
<h3 id="h3-Markt20Hotspots804580"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De openbare ketensector: SUI, FTM, SEI, enz. zijn gestegen, terwijl de vorige marktleiders ETH en SOL relatief zwak hebben gepresteerd. SUI steeg met 15% in 24 uur en naderde op een gegeven moment de $1,4. Het Sui ecosysteem meme project Blub is gestegen, met een huidige marktwaarde van $30 miljoen en is deze maand meer dan honderd keer gestegen.</p>
<p>Meme sector: NEIROCTO, NEIROETH, POPCAT en anderen zijn gestegen, waarbij NEIROCTO blijft stijgen en een historisch hoogtepunt bereikt. NEIROCTO is de afgelopen paar dagen met meer dan 200% gestegen en nadert de $0,001 markering. NEIROETH heeft een oversold herstel doorgemaakt na een scherpe daling in de afgelopen paar dagen, steeg met 40% binnen 24 uur en keerde momenteel terug naar boven $0,1. POPCAT is het toonaangevende kat-meme-project op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain, momenteel slechts één stap verwijderd van historische hoogtepunten. POPCAT wordt waarschijnlijk de eerste cat meme coin met een marktwaarde van meer dan $1 miljard.</p>
<h2 id="h2-Macroeconomie20De20Fed20verlaagt20de20rente20met205020basispunten20wat20leidt20tot20een20lichte20daling20op20de20algehele20aandelenmarkt607790"><a name="Macroeconomie: De Fed verlaagt de rente met 50 basispunten, wat leidt tot een lichte daling op de algehele aandelenmarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De Fed verlaagt de rente met 50 basispunten, wat leidt tot een lichte daling op de algehele aandelenmarkt</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager, waarbij de S&amp;P 500 index met 0,29% daalde tot 5.618,26 punten; De Dow Jones Industrial Average daalde met 0,25% tot 41.503,10 punten; De Nasdaq-index daalde met 0,31% tot 17.573,30 punten. Het referentiepunt voor de 10-jarige schatkistrendement bedraagt 3,70%, terwijl het rendement op de 2-jarige schatkist, dat het meest gevoelig is voor het rentebeleid van de Federal Reserve, 3,61% bedraagt.</p>
<p>Om 2:00 uur (Peking-tijd) vanochtend heeft de Federal Reserve zijn tweedaagse monetair beleidsvergadering afgerond en aangekondigd dat het de doelstelling voor het federaal fondsrente met 50 basispunten verlaagt naar 4,75% tot 5%, wat de eerste keer is dat de Fed de rente sinds 2020 heeft verlaagd. Deze aanpassing van het beleidsrente tarief markeert de officiële verschuiving van het monetair beleid van de Federal Reserve. Van maart 2022 tot juli vorig jaar heeft de Federal Reserve 11 keer achter elkaar de rente verhoogd gedurende meer dan een jaar, met een cumulatieve stijging van 525 basispunten. Sinds juli vorig jaar heeft het acht opeenvolgende vergaderingen gehouden zonder actie te ondernemen, en heeft het het beleidsrente tarief op een hoog niveau gehouden sinds 2001.</p>
<p>Een andere analyse suggereert dat een renteverlaging van 50 basispunten door de Federal Reserve ‘zeldzaam is in de afgelopen decennia’, wat aangeeft dat de Fed ervan overtuigd is dat de neerwaartse trend in de inflatie duurzaam is en nu zijn focus verlegt naar het bereiken van een zachte landing.</p>
<p>Ondanks de ‘massale’ renteverlaging van 50 basispunten door de Federal Reserve, bleef Powell’s monetaire beleidsverklaring op de persconferentie terughoudend. Powell gaf toe dat de Federal Reserve geen vooraf bepaald beleidstraject heeft en bij elke vergadering beslissingen zal blijven nemen. Als de economie stabiel blijft en de inflatie hardnekkig blijft, kunnen beleidsaanpassingen langzamer verlopen.</p>
<h3 id="h3-Conclusie959354"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Het algemene sentiment op de huidige markt is hersteld, gedreven door macro-economisch positief nieuws. Bitcoin en sommige Altcoins hebben een sterke prestatie laten zien, vooral in de Meme en GameFi sectoren waar tokens een significante opwaartse momentum hebben getoond. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en sommige activa vertonen echter nog steeds zwakte, en investeerders moeten de marktdynamiek en beleidswijzigingen nauwlettend in de gaten houden, voorzichtig handelen en activa redelijk toewijzen.</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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<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>