Qml0Y29pbiBFVEYtZ29lZGtldXJpbmc6IHBvdGVudGnDq2xlIGthdGFseXNhdG9yIHZvb3IgaGlzdG9yaXNjaGUgY3J5cHRvLXN0aWVyZW5sb29w

2023-11-15, 04:42

<p><img src="https://gimg2.gateimg.com/image/article/1700022800RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen364040"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De goedkeuring van de SEC <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s zullen waarschijnlijk een crypto bull run veroorzaken.</p>
<p>BlackRock en Fidelity zijn enkele grote institutionele beleggers die hebben aangevraagd voor spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s.</p>
<p>De toename van institutionele investeringen in bitcoin en zijn derivaten zal waarschijnlijk de prijs op korte en lange termijn verhogen.</p>
<h2 id="h2-Introductie770780"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De cryptomarkt heeft verwacht dat de Amerikaanse Securities and Exchange Commission in het vierde kwartaal van 2023 bitcoin exchange-traded funds (ETF’s) zou goedkeuren. Toch zijn degenen die de goedkeuring van de Bitcoin ETF-aanvraag dit jaar verwachtten, teleurgesteld omdat ze nog een paar maanden moeten wachten. Het is echter nog niet zeker dat de SEC de BTC ETF-aanvragen in het eerste kwartaal van 2023 zal goedkeuren.</p>
<p>Vandaag bespreken we de mogelijke impact van de goedkeuring van bitcoin ETF’s door de SEC, zoals een toename van institutionele investeringen in BTC en groeiend vertrouwen in cryptocurrencies. We zullen ook kijken naar de verschillen tussen spot en <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">futures gebaseerde ETF’s</a>.</p>
<h2 id="h2-Mogelijke20redenen20voor20uitstel20van20goedkeuring20van20Bitcoin20ETF20door20SEC160383"><a name="Mogelijke redenen voor uitstel van goedkeuring van Bitcoin ETF door SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mogelijke redenen voor uitstel van goedkeuring van Bitcoin ETF door SEC</h2><p>Er zijn verschillende mogelijke verklaringen voor de vertraging van de SEC in de goedkeuring van de bitcoin ETF-beslissing tot 2024. Ten eerste heeft de vertraging in het nemen van een definitief besluit veel speculatie binnen de crypto-sector veroorzaakt.</p>
<p>Echter, de SEC weet dat als het de eerste reeks spot crypto-ETF’s goedkeurt, er in de toekomst meer zullen komen. Bijvoorbeeld, kunnen we spot verwachten <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Ook ETF’s. Het is belangrijk op te merken dat er veel institutionele beleggers zijn die klaar staan om te investeren in crypto-ETF’s.</p>
<p>Sommige investeerders wachten af om te zien of de SEC de aanvragen voor spot BTC ETF zal goedkeuren, iets dat waarschijnlijk de belangrijkheid van cryptocurrencies, vooral bitcoin, zal bevestigen. Als zodanig, <a href="https://www.gate.io/blog_detail/3357/analyzing-the-sec-s-appeal-and-its-impact-on-grayscale-bitcoin-etf-ruling" target="_blank">als de SEC spot bitcoin ETF’s goedkeurt</a> Er zal naar verwachting veel kapitaalinstroom zijn naar de cryptosector.</p>
<p>Aan de andere kant geloven sommige investeerders dat de goedkeuring van <a href="https://www.gate.io/blog_detail/3421/weekly-web3-research-global-spot-btc-etf-assets-exceeded-4-billion-ordi-and-related-protocol-triggered-market-sentiment-the-nft-market-further-rebounded" target="_blank">De introductie van BTC ETF’s zal waarschijnlijk leiden tot een cryptobullrun</a>. Daarom blijven ze bereid om te investeren in populaire cryptocurrencies zoals bitcoin en Ethereum. Het is belangrijk op te merken dat we hebben gezien <a href="https://www.gate.io/es/blog_detail/3194/crypto-influencers-fuel-speculation-as-sec-delays-bitcoin-etf-decision" target="_blank">dergelijke SEC-regelgevende aarzelingen in het verleden</a> Uiteindelijk kan het ze echter goedkeuren.</p>
<h2 id="h2-Instroom20van20institutioneel20kapitaal20in20Crypto20ETFs649246"><a name="Instroom van institutioneel kapitaal in Crypto ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Instroom van institutioneel kapitaal in Crypto ETF’s</h2><p>De goedkeuring van ten minste één spot BTC ETF zal een belangrijke ontwikkeling worden voor de cryptomarkt. Bijvoorbeeld, goedkeuring van BTC in de Verenigde Staten zal ruimte creëren voor institutionele financiële instroom in de cryptomarkt. De reden hiervoor is dat spot bitcoin ETF’s gereguleerde financiële beleggingsactiva zijn met zeer lage risico’s.</p>
<p>Naast het aantrekken van kapitaalinjecties zal de komst van grote investeerders in de cryptocurrency-industrie ook essentiële expertise en andere middelen naar de sector brengen. Hiermee vergroten ze de liquiditeit, stabiliteit en geloofwaardigheid van de industrie.</p>
<p>Grote vermogensbeheerders, verzekeringsmaatschappijen, hedgefondsen en pensioenfondsen die in de sector beleggen, hebben bijvoorbeeld een gevestigde infrastructuur die de sector groei kan brengen. Ze hebben ook een goede staat van dienst en enorme ervaring in het naleven van regelgeving, wat vertrouwen schept in de branche.</p>
<h2 id="h2-Spot20Vs20Futuresgebaseerde20ETFs20Begrip20van20de20belangrijkste20verschillen173802"><a name="Spot Vs. Futures-gebaseerde ETF’s: Begrip van de belangrijkste verschillen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spot Vs. Futures-gebaseerde ETF’s: Begrip van de belangrijkste verschillen</h2><p>De spot BTC ETF’s en BTC Futures op ETF’s gebaseerd <a href="https://www.gate.io/blog_detail/3421/weekly-web3-research-global-spot-btc-etf-assets-exceeded-4-billion-ordi-and-related-protocol-triggered-market-sentiment-the-nft-market-further-rebounded" target="_blank">zijn beide bitcoin-derivaten</a> Een spot bitcoin ETF is een financieel beleggingsinstrument dat op elk moment de marktprijs van BTC volgt. Bitcoin ETF’s stellen beleggers in staat te profiteren van BTC prijsveranderingen zonder het te bezitten.</p>
<p>Integendeel, <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Bitcoin ETFs</a> zijn gekoppeld aan BTC-futurescontracten, niet aan de marktprijs ervan. Specifiek is de waarde van een bitcoin-futures-ETF gebaseerd op de verwachte toekomstige prijs van BTC en niet op de huidige marktwaarde ervan. In feite worden spot-bitcoin-ETF’s echter ondersteund door BTC die wordt bewaard in bewaarportefeuilles. De waarden van bitcoin-futures-ETF’s zijn echter gekoppeld aan marktspeculatie over toekomstige BTC-prijsbewegingen en de bijbehorende contractuele overeenkomsten.</p>
<p>Een vertegenwoordiger van <a href="https://www.galaxy.com/insights/research/sizing-the-market-for-a-bitcoin-etf/" rel="nofollow noopener noreferrer" target="_blank">Melkweg</a> gaf de volgende uitleg over ETF’s. “Een ETF is een meer direct gereguleerd aanbod dat de toegang voor een grotere populatie van investeerders zou vergroten. In plaats van te vertrouwen op vermogensbeheerders, kunnen ETF’s worden benaderd door een breder scala aan klanten, waaronder rechtstreeks bij een makelaar.”</p>
<p>Ondertussen verwacht Galaxy dat de sector in het eerste jaar meer dan $14 miljard zal aantrekken. <a href="https://www.galaxy.com/insights/research/sizing-the-market-for-a-bitcoin-etf/" rel="nofollow noopener noreferrer" target="_blank">Het verklaarde</a>“We schatten de adresseerbare marktomvang van een Amerikaanse Bitcoin ETF op $14 biljoen in jaar 1 na lancering, $26 biljoen in jaar 2 en $39 biljoen in jaar 3.” De volgende tabel toont de andere mogelijke financiële instromen in de sector.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1700023150ETF 1.png" alt=""><br>Geschatte financiële instroom na goedkeuring van BTC ETF’s - Galaxy</p>
<h2 id="h2-Interesse20van20BlackRock20en20Fidelity20in20Spot20Bitcoin20ETFs616823"><a name="Interesse van BlackRock en Fidelity in Spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interesse van BlackRock en Fidelity in Spot Bitcoin ETF’s</h2><p>BlackRock en Fidelity behoren tot de bedrijven die hebben <a href="https://www.gate.io/blog_detail/3312/what-are-bitcoin-etfs-and-why-investors-are-lining-up-gate-learn-offer-insight" target="_blank">aangevraagd voor Bitcoin ETT’s</a> in de Verenigde Staten. De betrokkenheid van dergelijke grote financiële instellingen duidt op de groeiende interesse van mensen en bedrijven in bitcoin en zijn derivaten.</p>
<p>Dergelijke bedrijven zullen helpen bij het integreren van de cryptocurrency-sector met de traditionele financiële sector. Dit kan helpen bij het vormgeven van de regelgevingsomgeving in de digitale industrie. Grayscale Investments en ARK Investment zijn voorbeelden van andere grote bedrijven die een aanvraag hebben ingediend voor spot bitcoin ETF’s.</p>
<h2 id="h2-Potentile20Bull20Run20over20Crypto20Market20Spot20Bitcoin20ETF20Goedkeuring20Boost20Altcoin55943"><a name="Potentiële Bull Run over Crypto Market: Spot Bitcoin ETF Goedkeuring Boost Altcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potentiële Bull Run over Crypto Market: Spot Bitcoin ETF Goedkeuring Boost Altcoin</h2><p>Het effect van spot bitcoin ETFS op de prijs van bitcoin is afhankelijk van het aantal dat door de SEC en andere regelgevende instanties wordt goedgekeurd. Zeker, met de loop van de tijd zullen we waarschijnlijk andere landen zien die spot BTC ETF’s goedkeuren, wat de vraag naar bitcoin zal vergroten.</p>
<p><a href="https://www.galaxy.com/insights/research/sizing-the-market-for-a-bitcoin-etf/" rel="nofollow noopener noreferrer" target="_blank">Melkweg</a> heeft zijn schatting gegeven van een mogelijke <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> verandert als de SEC spot bitcoin ETF’s goedkeurt. Het heeft voorspeld dat de bitcoinmarkt veel incrementele instroom kan hebben tussen $125bn en $450bn gedurende een langere periode. Een dergelijke financiële instroom in de bitcoinmarkt zal waarschijnlijk leiden tot meer dan 6,2% stijging van de prijs in de eerste maand.</p>
<p>Desalniettemin zal bitcoin waarschijnlijk gedurende een lange periode een aanhoudende prijsstijging ervaren, wat de prijs kan opdrijven. De prijsstijging van bitcoin zal waarschijnlijk overslaan naar de hele cryptomarkt, aangezien ze gecorreleerd zijn. Volgens <a href="https://twitter.com/Lab4crypto_/status/1694337583705153773" rel="nofollow noopener noreferrer" target="_blank">Lab4Crypto</a>, bitcoin en grote cryptocurrencies hebben een correlatie-index van bijna 1.0.</p>
<p>Lab4Crypo zei specifiek: ‘De correlatie tussen Bitcoin en altcoins is indrukwekkend dicht bij 1 (zeer sterke positieve lineaire relatie). Dit impliceert dat het observeren van de prijsbewegingen van Bitcoin kan dienen als een voorspellende indicator voor de richting van altcoins.’ De volgende diagram toont de correlatie van bitcoin met andere cryptocurrencies.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1700023256ETF 2.png" alt=""><br>Bitcoin correlatie met Altcoins - X-Lab4Crypto</p>
<p>Op basis van de bovenstaande analyse zal elke goedkeuring van bitcoin ETF waarschijnlijk een besmettingseffect hebben op de hele cryptomarkt, wat <a href="https://www.gate.io/blog_detail/1800" target="_blank">zal een crypto Bull Run ontsteken</a>, vooral als er een langdurige stijgende markt is.</p>
<h2 id="h2-Conclusie995050"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De cryptomarkt verwacht dat de SEC haar definitieve beslissing zal nemen over verschillende aanvragen voor spot bitcoin. Het is waarschijnlijk dat de SEC in het eerste kwartaal van 2024 enkele spot BTC ETF’s zal goedkeuren. De goedkeuring van de ETF’s kan meer institutionele investeringen in de sector aantrekken.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadviezen.<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 zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>