SG9lIGRlIHplZXIgdmVyd2FjaHRlIFNwb3QgQml0Y29pbiBFVEYgZGUgbWFya3QgYmXDr252bG9lZHQ=

2023-11-10, 09:52

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR315012"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De goedkeuring van de spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s betekent de acceptatie en erkenning van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> door de traditionele mainstream wereld, wat zal bijdragen aan de grootschalige adoptie van Bitcoin in de praktijk, waardoor het de aandacht van de markt trekt.</p>
<p>Op 8 november 2023 zijn er wereldwijd ongeveer 20 actieve spot Bitcoin ETF-producten, met een totaal vermogen van $4,16 miljard.</p>
<p>De invoer van spot Bitcoin ETF’s is nabij. Geconfronteerd met de mogelijke instroom van enorme fondsen, moet de cryptogemeenschap overwegen om de uitbreiding van de werkelijke adoptiesnelheden en de oorspronkelijke bedoeling van decentralisatie in evenwicht te brengen.</p>
<h2 id="h2-Inleiding727317"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Eind oktober heeft een reeks progressieve nieuwsberichten over de aanvraag voor een Amerikaans spot Bitcoin ETF aanzienlijk bijgedragen aan de sterke stijging van de Bitcoin-prijzen en heeft de algehele positieve trend van de markt tot op heden voortgezet.</p>
<p>Waarom hebben spot ETF’s zo’n significante impact op het marktvertrouwen, wat is het huidige marktpatroon van spot ETF’s, en hoe de voordelen en nadelen van dit product te ueren? Het artikel zal alle vragen uitleggen.</p>
<h2 id="h2-Een20reis20van201020jaar20om20Spot20Bitcoin20ETFs20aan20te20vragen322043"><a name="Een reis van 10 jaar om Spot Bitcoin ETF’s aan te vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een reis van 10 jaar om Spot Bitcoin ETF’s aan te vragen</h2><p>De goedkeuring van spot Bitcoin ETF’s betekent de acceptatie en erkenning van Bitcoin door de traditionele mainstream wereld, wat bijdraagt aan de grotere adoptie van Bitcoin in de praktijk en altijd al een focus van marktaandacht is geweest.</p>
<p>De vroegste Bitcoin ETF-aanvraag kan worden herleid tot juli 2013, toen de mede-oprichters van Gemini, Cameron en Tyler Winklevoss, hun eerste ETF-aanvraag indienden bij de Amerikaanse SEC. Maar destijds waren regelgevende instanties en zelfs potentiële investeerders niet erg bekend met cryptocurrencies, en de SEC wees de aanvraag direct af, waarmee een spelreis van 10 jaar begon.</p>
<p>In april 2019 verspreidde het nieuws over de goedkeuring van een Bitcoin ETF zich snel, wat de bearish markt aanzienlijk stimuleerde. Hoewel het nieuws later werd vervalst, bleef de marktsentiment hoog en veroorzaakte Bitcoin een golf van bullmarkt trends dat jaar, wat wijst op de significante impact van Bitcoin ETF-producten op de markt.</p>
<p>In feite werd de algemeen bekende Grayscale Bitcoin Trust (GBTC), die oorspronkelijk een fonds was dat bezig was met het aanvragen van een ETF, omgezet in een trust vanwege het niet verkrijgen van goedkeuring van de Amerikaanse SEC. Hoewel GBTC geen ETF was, was het destijds het eerste en enige beleggingsproduct dat verhandelbaar was op de Amerikaanse aandelenmarkt en de prijs van Bitcoin kon volgen, wat resulteerde in een hoge premie ten opzichte van de werkelijke prijs van Bitcoin na uitgifte.</p>
<p>In de Bitcoin bullmarkt van 2020 was Grayscale in een overgewichtstoestand, wat een belangrijke indicator werd van de bullishness van de markt op dat moment.</p>
<p>De wereldwijde eerste spot ETF werd ook tijdens deze periode uitgegeven en genoteerd. De eerste die werd gelanceerd was de Duitse ETC Group Physical Bitcoin, die in juni openbaar werd verhandeld, gevolgd door het 3iQ Bitcoin Fonds en VanEck Bitcoin ETN, die werden gelanceerd in het vierde kwartaal.</p>
<p>Nadat de Grayscale-aanvraag om Bitcoin Trust GBTC om te zetten in een spot ETF werd afgewezen in 2021, werd dat jaar de Bitcoin-futures ETF goedgekeurd voor uitgifte door de SEC.</p>
<p>Op het moment dat de Amerikaanse SEC zich zorgen maakte over het gebrek aan transparantie en liquiditeit in transacties, evenals marktmanipulatie, wat leidde tot trage vooruitgang, namen Canada, Brazilië en andere landen het voortouw bij het goedkeuren van de uitgifte van spot Bitcoin ETF’s tijdens de opwinding van de stierenmarkt van 2021, wat hielp om de Bitcoin-prijzen aanzienlijk te verhogen.</p>
<p>In 2023 hebben landen zoals het Verenigd Koninkrijk en Duitsland ook spot Bitcoin ETF’s uitgegeven, en Hong Kong, China, heeft ook twee futures ETF’s goedgekeurd. Hun handelsschaal is echter te klein en hun invloed is beperkt. De marktaandacht blijft gericht op de voortgang van veel instellingen in de Verenigde Staten die wachten op goedkeuring.<img src="https://gimg2.gateimg.com/image/article/169960982914391699609401_.pic.jpg" alt=""><br>Overzicht van CSOP Bitcoin Futures ETF-producten Figuur 1 Bron: csopasset.com</p>
<p>In feite heeft de Amerikaanse SEC sinds 2017 op basis van de normen voor de bescherming van beleggers en het algemeen belang meer dan tien aanvragen voor dergelijke ETF’s afgewezen, maar er vinden positieve veranderingen plaats.</p>
<p>Na herhaalde confrontaties begon de houding van de Amerikaanse SEC ten aanzien van de beoordeling te verzachten. Enerzijds won Grayscale de rechtszaak tegen de SEC en moest de SEC de aanvraag voor Grayscale GBTC-conversie heroverwegen. Anderzijds begonnen instellingen zoals BlackRock die een aanvraag indienen voor spot ETF’s, productinformatie in te dienen bij de Amerikaanse Effectenbewaar- en Clearingmaatschappij (DTCC), hoewel dit niet betekent dat de SEC de aanvraag officieel heeft goedgekeurd, maar positieve tekenen van vooruitgang duiden ongetwijfeld aan dat het evenement op het punt staat te worden voltooid.</p>
<h2 id="h2-De20marktpatroon20van20spot20Bitcoin20ETFs940293"><a name="De marktpatroon van spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De marktpatroon van spot Bitcoin ETF’s</h2><p>Op 8 november 2023 zijn er wereldwijd ongeveer 20 actieve spot Bitcoin ETF-producten, met een totale waarde van $4,16 miljard; Er zijn ook 7 futures ETF-producten, voornamelijk gevestigd in de Verenigde Staten (5) en Hongkong, China (2).</p>
<p>Volgens de gegevens van CoinGecko heeft Canada 7 van de 20 spot Bitcoin ETF-producten wereldwijd, goed voor bijna 50% van de omvang van het vermogen. Het grootste openbare Bitcoin ETF (BTCC) beheert bijna $820 miljoen aan activa, zoals gedetailleerd in de onderstaande tabel.<br><img src="https://gimg2.gateimg.com/image/article/1699855251WechatIMG1449.jpg" alt=""><br>Tabel 2 Bron: CoinGecko</p>
<p>Op dit moment zijn Canada en Europa de belangrijkste markten voor spot Bitcoin ETF’s.</p>
<p>Canada heeft het grootste aantal eerder uitgegeven producten van dit type. Het 3iQ Bitcoin Fund (QBTC) van Canada werd al in 2021 gelanceerd op de Dubai Nasdaq, waardoor er een breder scala aan financieringsbronnen beschikbaar is.</p>
<p>Sinds de berenmarkt van vorig jaar is er geen significante toename geweest in Canadese BTC-holdings in deze categorie van producten.</p>
<p>Duitsland was het eerste land dat spot Bitcoin ETF’s uitgaf, met een totaal vermogen van $800 miljoen. Bovendien zijn er andere Europese producten van dit type geregistreerd in belastingparadijzen, maar ze hebben weinig invloed op de cryptomarkt, zoals Brazilië en Australië, en hebben weinig impact op de cryptomarkt.</p>
<p>Als alles so blijft verlopen, zal de VS tegen begin volgend jaar 12 spot Bitcoin ETF’s lanceren, mits de Amerikaanse SEC alle huidige aanvragen goedkeurt. Meer producthoeveelheden, evenals mogelijke enorme fondsen, zullen de Verenigde Staten in beweging houden.</p>
<h2 id="h2-Is20het20Reddingsteam20hier20of20is20de20Wolf20hier27262"><a name="Is het Reddingsteam hier of is de Wolf hier?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het Reddingsteam hier of is de Wolf hier?</h2><p>Volgens veel analisten zal de goedkeuring van de Amerikaanse spot Bitcoin ETF de deelname en interesse van veel investeerders en handelsinstellingen aantrekken, de adoptiesnelheid van Bitcoin versnellen, de waarde van Bitcoin en zelfs de hele cryptomarkt verbeteren, en een belangrijke mijlpaal zijn in de ontwikkeling van de cryptomarkt.</p>
<p>Bijvoorbeeld, NYDIG in de Verenigde Staten verklaarde dat zodra uitgegeven en genoteerd, de omvang van het vermogensbeheer van deze producten $28,8 miljard zou bedragen, waarvan $27,6 miljard zou worden geïnvesteerd in spotproducten.</p>
<p>Bitwise, ‘s werelds grootste virtuele valuta-indexfondsbeheermaatschappij, is optimistischer. CEO Matt Hougan verklaarde dat als het product kan worden goedgekeurd, de totale omvang van spot Bitcoin ETF’s snel tientallen miljarden dollars kan bereiken.</p>
<p>Hij schatte dat het binnen vijf jaar ongeveer $50 miljard aan fondsen kan aantrekken, en de prijsstijging na de beursgang kan de schaal verder vergroten.<br><a href="/price/polymath-poly" rel="nofollow noopener noreferrer" target="_blank">poly prijs</a><br>Figuur 3 Bron: @ Matt_ Hougan</p>
<p>Maar niet iedereen heeft een positieve houding. Arthur Hayes gelooft dat de toestroom van Wall Street-instellingen een negatieve impact kan hebben en dat de toetreding van financiële instellingen die de nationale wil vertegenwoordigen, online consensus kunnen manipuleren en gemeenschapsinnovatie kunnen smoren.</p>
<p>Hij verklaarde in een column dat het een twijfelachtige vraag is of zij (verwijzend naar instellingen zoals BlackRock) deze upgrades zullen ondersteunen. Het is duidelijk dat wanneer passieve houders van grootschalige aandelen opduiken in het ecosysteem, er meer onzekerheid zal zijn over deze kwestie.</p>
<p>Alles heeft twee kanten. Enerzijds kijkt de crypto-gemeenschap reikhalzend uit naar het goedkeuringsproces van ETF’s, in de hoop op waardegroei door de voordelen. Aan de andere kant moet de gemeenschap goed nadenken op de lange termijn en effectieve reactieplannen zoeken.</p>
<p>De invoer van spot Bitcoin ETF’s is aanstaande. Geconfronteerd met de mogelijke instroom van enorme fondsen, kan het in evenwicht brengen van het vergroten van de werkelijke acceptatiegraad en het handhaven van decentralisatiebedoelingen een langetermijnprobleem zijn waar mensen onder de huidige trend op moeten letten.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>