S29tdCBkZSBCaXRjb2luIEJ1bGwgTWFya2V0IGVjaHQgbnUgZGUgbXVudHByaWp6ZW4gbmFhciAkMzVLIHN0aWpnZW4/

2023-10-31, 09:38

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR606501"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Het laterale voortgangsnieuws van spot ETF’s is een belangrijke drijvende kracht achter de recente stijging in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Temidden van de opwinding van de bullmarkt zijn MEME, GameFi, AI en andere sectoren, evenals sommige veteran oversold project tokens, gestegen, waarbij het urgente herstelsentiment dat onderdrukt werd door de bearmarkt wordt benadrukt.</p>
<p>De instroom van fondsen vanuit ETF’s, het verhaal van de vierde halvering en de verwachting van de volgende Fed-rente verlaging volgend jaar, geven allemaal aan dat de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> markt een meer positief waarde ontdekkingsproces zal doormaken.</p>
<h2 id="h2-Introductie553708"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Nu het nieuws de ronde doet dat de authenticiteit van spot Bitcoin ETF’s moeilijk te onderscheiden is, is de recente <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> is snel gestegen naar het hoogste niveau van $35.000 na een lichte correctie van $30.000, en heeft daarmee sinds het begin van dit jaar een nieuw hoogtepunt bereikt. Daarnaast is Altcoin ook in een stroomversnelling geraakt, waardoor veel investeerders zich afvragen: Is er echt een bullmarkt aangebroken?</p>
<p>Is de huidige stijging van Bitcoin een sterke opleving in de berenmarkt of een terugkeer naar de stierenmarkt trend? Dit artikel zal iedereen laten nadenken over de huidige marktsituatie en de redenen achter de stijging ontrafelen.</p>
<h2 id="h2-Zijdelings20nieuws20over20spotETFs20helpt20Bitcoin20omhoog20te20schieten513955"><a name="Zijdelings nieuws over spot-ETF’s helpt Bitcoin omhoog te schieten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijdelings nieuws over spot-ETF’s helpt Bitcoin omhoog te schieten</h2><p>De scherpe stijging van de Bitcoin-prijzen hangt nauw samen met het recente positieve nieuws over spot Bitcoin ETF’s in de Verenigde Staten.</p>
<p>Eind oktober heeft de Amerikaanse districtsrechtbank het proces tussen Grayscale en de SEC goedgekeurd, wat aangeeft dat er bijna geen juridische obstakels zijn in het proces van het omzetten van GBTC (Bitcoin Trust Fund) in een ETF, terwijl de spot Bitcoin ETF van BlackRock ook aanzienlijke vooruitgang heeft geboekt.</p>
<p>Op 24 oktober oordeelde het Hof van Beroep van Washington D.C. over het geschil tussen de SEC en Grayscale, waarbij de SEC werd verplicht om de aanvraag van Grayscale aan te pakken.</p>
<p>Daarom past Grayscale niet alleen toe om GBTC om te zetten in spot Bitcoin ETF’s, maar past het ook toe op de SEC om ETHE om te zetten in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Trust Fund) in spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETFs.</p>
<p>Spoedig toonde de officiële website van de SEC aan dat het de indieningsinformatie voor de wijzigingen in de noterings- en handelsregels van Grayscale Ethereum had geaccepteerd.</p>
<p>Tegelijkertijd verspreidde het nieuws zich dat de spot Bitcoin ETF van BlackRock een CUSIP-nummer had verkregen en begon met de verkoop van ‘Seed’-fondsen. Nadat de spot Bitcoin ETF van BlackRock met de code IBTC op de website van DTCC, een belangrijke financiële markttoolprovider in de Verenigde Staten, verscheen, werd de hele markt eindelijk opgewonden en steeg enkele uren later snel naar $35.000. Dit is een terugkeer naar het niveau van het bullish vertrouwen sinds de daling onder $35.000 in mei vorig jaar.<img src="https://gimg2.gateimg.com/image/article/169874495312421698744722_.pic.jpg" alt=""><br>Afbeelding 1: Bitcoin-prijstrends Bron: Gate.io</p>
<p>Zoals bekend, zullen spot Bitcoin ETF’s een gereguleerd mainstream beleggingsinstrument bieden voor Amerikaanse investeerders, waardoor ze kunnen investeren in Bitcoin zonder rechtstreeks cryptocurrency te bezitten. Dit is een belangrijke stap in de mainstream adoptie van Bitcoin, en waarnemers en investeerders kijken ook uit naar de intrede van een grote hoeveelheid over-the-counter fondsen, die mogelijk kunnen bijdragen aan de waardeverhoging van Bitcoin.</p>
<p>Bijvoorbeeld wees Matricport er in een recent uitgebracht rapport op dat Bitcoin zich momenteel in zijn vijfde bull marktcyclus bevindt, en de verwachtingen die door instellingen worden aangenomen, kunnen de belangrijkste drijvende kracht zijn van de vijfde bull markt. Daarnaast overwegen instellingen Bitcoin als een manier om de diversificatie van activaspreiding te realiseren, omdat Bitcoin vergelijkbare kenmerken heeft als andere veilige haven investeringen zoals goud en schatkistobligaties.</p>
<p>Volgens een recent onderzoek van Galaxy wordt geschat dat in het eerste jaar na de lancering van ETF’s de instroom van Bitcoin ETF’s $14 miljard kan bedragen, gevolgd door respectievelijk een toename van $27 miljard en $39 miljard. Over een lange periode is de potentiële toename van incrementele fondsen voor Bitcoin-beleggingsproducten ongeveer $125 miljard tot $450 miljard.</p>
<h2 id="h2-De20Frenzy20van20het20Altcoin20Seizoen70057"><a name="De Frenzy van het Altcoin Seizoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Frenzy van het Altcoin Seizoen</h2><p>In tegenstelling tot eerdere keren, toen Bitcoin alleen steeg, zijn deze keer Altcoins ook gestegen en zelfs een stijging gezien in verschillende sectoren, wat herinneringen oproept aan de ‘bullmarkt’ bij mensen. Een zeer significante emotionele observatie-indicator, de Greed and Panic Index, bereikte op 25 oktober 72, wat gelijk is aan de piek van Bitcoin van $69.000 twee jaar geleden.<img src="https://gimg2.gateimg.com/image/article/169874498412431698744733_.pic.jpg" alt=""><br>Marktangst- en gretigheidsindex figuur 2 Bron: alternative.me</p>
<p>Te midden van de opwinding van de stierenmarkt zijn MEME, GameFi, AI en andere sectoren, evenals sommige veteranen van oververkochte projecttokens, gestegen, waarbij het urgente herstelsentiment dat onderdrukt wordt door de bearmarkt wordt benadrukt.</p>
<p>In de MEME-sector zijn oude en opkomende tycoons zoals PEPE, DOGE en SHIBA gestegen. Floki heeft het tokenisatieplatform TokenFi gelanceerd en zijn token TOKEN heeft een honderdvoudige mythe gecreëerd. Het NFT-project Memeland heeft nog meer opvallende prestaties geleverd en heeft gebruik gemaakt van deze kans om Memecoin uit te geven, met een voorverkoopbedrag van 8737131 ETH (ongeveer $15,667 miljoen).</p>
<p>De GameFi-sector blijft de trend van BigTime volgen, met AXS, APE en SLP vertegenwoordigd door Axis Infinity die sterk stijgen. Tegelijkertijd MC, <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a>, GMT, and andere sectoren maken ook een gemeenschappelijke situatie mee.</p>
<p>De AI-sector werd begunstigd door fondsen vanwege de eerste kunstmatige intelligentie conferentie op 6 november, met AGIX, FET, OCEAN, FREE en andere sectoren die de weg leiden in groei.</p>
<p>Natuurlijk zijn niet alle sectoren booming. Tegen de achtergrond van de vertraagde upgrade van Cancun is de prestatie van sommige L2-projecttokens en sommige onpopulaire tracks zoals sport, privacy en sociale media relatief middelmatig.</p>
<h2 id="h2-Toekomstperspectieven768296"><a name="Toekomstperspectieven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectieven</h2><p>Over het algemeen hebben BlackRock’s spot ETF’s pre-IPO-voorbereidingen ontvangen. Hoewel het nieuws meerdere keren is herhaald, heeft het uiteindelijk geleid tot een doorbraak in de marktkracht die al 200 dagen kracht heeft opgebouwd, en een reeks shortposities heeft ook bijgedragen aan de uitbraak van de markt.</p>
<p>Uit de koers van de afgelopen paar bull markets is gebleken dat verschillende Altcoins aanzienlijk zijn hersteld met de opkomst van Bitcoin, wat aangeeft dat de marktsentimenten zijn verschoven van bearish naar bullish. Echter, in de perifere situatie waarin de Federal Reserve hoge rentetarieven handhaaft, heeft de crypto markt nog steeds nieuwe technologie en product innovatie nodig om de persistentie van marktbullish sentiment te verbeteren, wat nog steeds de moeite waard is om naar uit te kijken.</p>
<p>In feite lijkt deze stijging meer op een emotionele ontlading na langdurige onderdrukking onder de stimulatie van positief nieuws.</p>
<p>Echter is deze uitbarsting niet zonder grond, als we de marktwaarde van stablecoins, die de belangrijkste maatstaf van marktgezondheid is, als voorbeeld nemen. In de afgelopen week is de marktwaarde van USDT, als de belangrijkste handelskracht, met meer dan $630 miljoen gestegen, en zijn crypto-activa-investeringsproducten vier opeenvolgende weken netto instroom geweest. De recente instromen zijn gerelateerd aan de gunstige voortgang van spot Bitcoin ETF’s aangevraagd door instellingen zoals BlackRock. De instromen tot nu toe deze maand hebben nu bijna $500 miljoen bereikt.</p>
<p>Het lijkt echter nog te vroeg om te spreken over een alomvattende bullmarkt. Vergeleken met de vorige ronde van bullmarkten is de huidige on-chain activiteit nog steeds relatief rustig en is de marktwaarde van de stablecoin-aanbod licht afgenomen. Daarom strijden verschillende verhalen om beperkt kapitaal zonder de liquiditeit te verbeteren, wat heeft geleid tot een snelle en zwakke duurzaamheid van de sectorrotatie.<img src="https://gimg2.gateimg.com/image/article/169874503212441698744744_.pic.jpg" alt=""><br>De voorraad stablecoin is nog steeds niet hersteld. Figuur 3 Bron: DefilLama</p>
<p>Sinds het begin van dit jaar is het lang sluimerende Bitcoin-ecosysteem geleidelijk welvarend geworden. De NFT- en BRC-20-protocollen met inies hebben met succes een golf van FOMO-hype teweeggebracht, en de opkomst van protocollen zoals BitVM en Taproot Assets heeft ook een ontwikkelingsboom voor Bitcoin Layer2 teweeggebracht. Vanuit een macro-perspectief heeft Bitcoin, tegen de achtergrond van nog niet ontspannen mondiale liquiditeit en regionale spanningen, aanzienlijke vooruitgang geboekt bij het bekijken van spot-ETF’s, wat heeft geleid tot zijn relatief sterke kant en heeft zijn hoeksteenrol als leider op de cryptomarkt aangetoond.</p>
<p>Samengevat duiden toekomstige instromen van fondsen uit ETF’s, het verhaal van de vierde halvering en de verwachtingen voor de renteverlaging van de Federal Reserve volgend jaar erop dat de Bitcoin-markt een meer positief waardeontdekkingsproces zal inluiden.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 wordt juridische actie ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>