R3JheXNjYWxlIGdhYXQgZG9vciBtZXQgU3BvdCBCaXRjb2luIEVURiwgdm9lcnQgZG9vcmxvcGVuZGUgZ2VzcHJla2tlbiBtZXQgU0VD

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>De SEC kan verschillende spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF-aanvragen tussen 5 en 10 januari 2024.</p>
<p>Onlangs heeft de SEC vergaderingen gehad met potentiële uitgevers van spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s.</p>
<p>Tot nu toe hebben 12 vermogensbeheerders zich aangemeld voor spot bitcoin ETF’s.</p>
<p>Trefwoorden: Spot Bitcoin ETF, Grayscale spot bitcoin ETF, goedkeuring van spot bitcoin ETF, goedkeuring van SEC voor een spot bitcoin ETF, BTC ETF, crypto ETF</p>
<h2 id="h2-Introductie901819"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Er is veel gesproken in de cryptomarkt over de mogelijke lancering van spot bitcoin exchange traded funds (ETF’s). Veel analisten geloven dat de goedkeuring van crypto-ETF’s waarschijnlijk zal leiden tot een toename van de adoptie en vraag naar cryptocurrencies. Grayscale, BlackRock, WisdomTree, Fidelity en Valkyrie zijn enkele van de vermogensbeheerders die <a href="https://www.gate.io/de/blog_detail/3479/daily-news-czs-confession-boosts-the-approval-of-bitcoin-spot-etfs-multiple-defi-platforms-funds-stolen-accumulated-losses-exceeding-dollar150-million" target="_blank">aangevraagd voor spot bitcoin ETF’s</a>.</p>
<p>In deze post gaan we in op de voortgang die Grayscale heeft geboekt bij het overtuigen van de Securities and Exchange Commission van de Verenigde Staten om zijn spot bitcoin ETF goed te keuren. We zullen ook de mogelijke tijdslijn bespreken voor de goedkeuring van spot bitcoin ETFs door de SEC.</p>
<h2 id="h2-Vooruitgang20in20plannen20voor20Spot20Bitcoin20ETF925825"><a name="Vooruitgang in plannen voor Spot Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vooruitgang in plannen voor Spot Bitcoin ETF</h2><p>Op 22 november heeft Grayscale zijn herziene prospectus ingediend voor een spot bitcoin ETF bij de SEC. Het doel is om zijn GBTC-fonds om te zetten in een spot BTC ETF. In zijn laatste indiening heeft Grayscale waarschijnlijk de overstap gemaakt van zijn in-kind model naar het ‘Cash’ model, dat een veiliger model is, om aan de belangrijkste eisen van de SEC te voldoen. <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">zorgen over spot Bitcoin ETF-aanvragen</a>.</p>
<p>Al reeds, <a href="https://www.sec.gov/comments/sr-nysearca-2021-90/srnysearca202190-305159-785022.pdf" rel="nofollow noopener noreferrer" target="_blank">Grayscale heeft</a> ontmoette de SEC om zijn voorgestelde te bespreken <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">bitcoin ETF</a>. Het is belangrijk op te merken dat Grayscale in de loop der jaren een goede relatie met de SEC heeft onderhouden vanwege zijn Grayscale Bitcoin Trust (GBTC), het streeft er nu naar om te worden omgezet in een spot crypto ETF.</p>
<p>De SEC heeft echter de eerste spot BTC ETF-aanvraag van Grayscale afgekeurd, waardoor het vermogensbeheerbedrijf een federale rechtbank moest inschakelen voor juridische bijstand. Als gevolg hiervan concludeerde een panel van federale rechters dat de SEC ‘willekeurig en grillig’ was in haar afwijzing van de aanvraag voor de Grayscale spot bitcoin ETF.</p>
<p>Daarmee b de rechtbank de SEC om de aanvraag van Grayscale te beoordelen. Een bron die CoinDesk aanhaalt, zei dat Grayscale onlangs onderhandelingen is gestart met de SEC. Volgens CoinDesk, <a href="https://www.coindesk.com/policy/2023/11/08/us-sec-said-to-open-talks-with-grayscale-on-spot-bitcoin-etf-push/#:~:text=The%20U.S.%20Securities%20and%20Exchange%20Commission%20(SEC" rel="nofollow noopener noreferrer" target="_blank">Craig Salm, een vertegenwoordiger van Grayscale zei</a>%20heeft%20gesprekken%20geopend, kan%20verstrekkende%20gevolgen%20hebben%20voor “Craig Salm, een vertegenwoordiger van Grayscale zei”), “Op dit moment zijn we erop gericht om op een constructieve manier opnieuw in contact te treden met de handel en markten.”</p>
<p>Hij voegde eraan toe: ‘Er zijn nog steeds dingen die moeten worden uitgewerkt. Over het algemeen is het een goede betrokkenheid geweest en het is een kwestie van wanneer, niet meer een kwestie van of.’</p>
<p>Hoewel Salm geen gedetailleerdere informatie heeft verstrekt over de onderhandelingen of gesprekken, heeft zijn feedback een positief sentiment gecreëerd binnen de markt dat de SEC de aanvraag van Grayscale kan goedkeuren. Naast Grayscale betrekt de SEC ook andere vermogensbeheerders bij hun aanvragen voor spot crypto ETF’s.</p>
<p><strong>Lees ook: </strong><br><a href="https://www.gate.io/blog_detail/3479/daily-news-czs-confession-boosts-the-approval-of-bitcoin-spot-etfs-multiple-defi-platforms-funds-stolen-accumulated-losses-exceeding-dollar150-million" target="_blank">Bekentenis van CZ stimuleert de goedkeuring van Bitcoin Spot ETFs</a> <a href="https://www.gate.io/blog_detail/3317/blackrock-sees-shift-spot-btc-etf" target="_blank">Voormalig BlackRock MD ziet verschuiving in sentiment naar Spot Bitcoin ETF</a></p>
<p>In feite wacht de cryptosector op goedkeuring van de SEC voor een spot bitcoin ETF, die zal helpen om veel investeringen voor de industrie aan te trekken. Verwacht wordt dat institutionele en particuliere beleggers binnen de eerste paar maanden na de lancering van een spot crypto ETF meer dan $3 miljard dollar in de sector zullen storten. De goedkeuring van meer dan één BTC ETF door de SEC zal waarschijnlijk veel meer fondsen voor de industrie genereren.</p>
<p>Ondertussen zijn er veel grote spelers in de vermogensbeheersector, zoals Amplify Investments, ProShares en Roundhill, die nog niet zijn begonnen met de race om hun spot crypto ETF’s te lanceren.</p>
<p>Deze organisaties geloven dat de markt verzadigd is, de marketingkosten hoog zijn en de producten sterk gereguleerd zijn. Tegelijkertijd zijn ze niet zeker of er voldoende vraag zal zijn naar deze beleggingsinstrumenten.</p>
<h2 id="h2-Het20Potentile20Spot20Bitcoin20ETF20Goedkeuringsvenster191989"><a name="Het Potentiële Spot Bitcoin ETF Goedkeuringsvenster" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Potentiële Spot Bitcoin ETF Goedkeuringsvenster</h2><p>De goedkeuring van de spot bitcoin ETF zal naar verwachting plaatsvinden tussen 5 en 10 januari 2024. Aangezien 6 en 7 in het weekend vallen, zou de goedkeuring moeten plaatsvinden in de week die begint op 8 januari. James Seyffart’s, een analist van Bloomberg, voorspelling is gebaseerd op het feit dat de deadline voor de ARK-beslissing 10 januari is.</p>
<p>Seyffart plaatste zijn voorspelling op X. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Hij schreef</a>, “Oké het raam <a href="https://www.gate.io/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">voor mogelijke goedkeuring van spot Bitcoin ETF</a> lijkt het erop dat het tussen 5 januari en 10 januari 2024 zal zijn.</p>
<p>Een andere analist, Scott Johnsson, is het eens met Seyffart. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “SEC publiceert morgen in het federale register (“12⁄1) de vertragingen van Franklin/Hashdex. Een snellere doorlooptijd dan normaal geeft opnieuw aan dat dit gaat over het afstemmen van mogelijke goedkeuringen.</p>
<p>Daarom verwacht hij ook dat de goedkeuringen zullen plaatsvinden tussen 5 en 10 januari. Zijn reden hiervoor is gebaseerd op de snelle reactie van de SEC op de indiening van Franklin. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Seyffart reageerde</a>, “Wow. SEC ging super vroeg op Franklin. Ze waren pas op 1 januari aan de beurt voor een beslissing. Opmerkelijk is dat Franklin de enige uitgever is die nog geen bijgewerkte S-1 heeft ingediend. Vraag me af <a href="https://www.gate.io/blog_detail/3461/glassnode-insights-finance-bridge-spotlight-on-spot-bitcoin-etfs-and-their-impact" target="_blank">als dat hier enige impact heeft</a>.”</p>
<p>Volgens Bloomberg is de eerste deadline voor Franklin en HashDex 5 januari, zoals blijkt uit de volgende tabel.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17024354331.png" alt=""><br>Schattingen en deadlines voor goedkeuring van Spot Bitcoin ETF - Seyff (X)</p>
<p>De tabel toont 12 spot Bitcoin ETF-aanvragen, waarvan sommige tussen 5 en 10 januari 2024 kunnen worden goedgekeurd. Aangezien sommige van deze aanvragen eerdere goedkeuringsvensters hebben, is het zeer waarschijnlijk dat ze deze keer worden goedgekeurd.</p>
<p>Bovendien toont het feit dat Grayscale John Hoffman, een voormalig Invesco ETF-utive, heeft aangenomen als managing director, het vertrouwen van het bedrijf dat de SEC waarschijnlijk zijn spot BTC ETF zal goedkeuren. Hoffman is bestemd om het hoofd van distributie en strategische partnerschappen te worden.</p>
<h2 id="h2-De20vertraging20van20de20SEC20bij20de20Hashdexvergadering20duidt20op20een20positieve20vooruitzicht20voor20mogelijke20goedkeuring20van20Bitcoin20ETF910401"><a name="De vertraging van de SEC bij de Hashdex-vergadering duidt op een positieve vooruitzicht voor mogelijke goedkeuring van Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De vertraging van de SEC bij de Hashdex-vergadering duidt op een positieve vooruitzicht voor mogelijke goedkeuring van Bitcoin ETF</h2><p>Seyffart heeft ook een andere mogelijke indicatie gegeven van de bereidheid van de SEC om in de nabije toekomst verschillende spot bitcoin ETF’s goed te keuren. Volgens hem ontmoette de SEC Hashdex op 27 november, een teken van zijn voortdurende betrokkenheid bij de verschillende vermogensbeheerders die een aanvraag hebben ingediend voor spot BTC ETF’s.</p>
<p><a href="https://twitter.com/JSeyff/status/1730236396428816528" rel="nofollow noopener noreferrer" target="_blank">Seyffart geplaatst</a>, “ <a href="https://twitter.com/JSeyff/status/1730236396428816528/photo/1" rel="nofollow noopener noreferrer" target="_blank">De SEC ontmoette Hashdex</a> op maandag de 27e en toen gaf de SEC de volgende dag een uitstelbevel uit voor hun aanvraag. Dit is weer een in een reeks <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> van aanwijzingen dat de SEC hard werkt met potentiële Bitcoin ETF-uitgevers aan backend-details en leidingen.</p>
<p>De ontmoeting van de SEC met Hashdex vindt plaats ongeveer een week nadat het met vertegenwoordigers van BlackRock heeft gesproken, ook om hun crypto-ETF’s te bespreken. Dit alles heeft de markt in afwachting gebracht dat de SEC in januari 2024 meer dan één spot bitcoin ETF zou kunnen goedkeuren.</p>
<h2 id="h2-Conclusie947339"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Verschillende potentiële spot bitcoin ETF-emittenten hebben onlangs een ontmoeting gehad met de SEC om problemen met betrekking tot hun toepassingen te bespreken. Vanwege dergelijke bijeenkomsten en andere indicaties hebben sommige investeringsanalisten voorspeld dat de SEC in januari 2024 verschillende spot bitcoin ETF-aanvragen zou kunnen goedkeuren.</p>
<h2 id="h2-Veelgestelde20vragen20over20Spot20Bitcoin20ETFs431668"><a name="Veelgestelde vragen over Spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Spot Bitcoin ETF’s</h2><h3 id="h3-Zal20de20Bitcoin20spot20ETF20goedgekeurd20worden172265"><a name="Zal de Bitcoin spot ETF goedgekeurd worden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal de Bitcoin spot ETF goedgekeurd worden?</h3><p>De SEC zal naar verwachting één of meer spot bitcoin ETF’s goedkeuren tussen 5 en 10 januari 2024. Momenteel is het betrokken bij de verschillende potentiële spot bitcoin ETF-uitgevers.</p>
<h3 id="h3-Wat20is20een203x20gehefde20Bitcoin20ETF643339"><a name="Wat is een 3x gehefde Bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een 3x gehefde Bitcoin ETF?</h3><p>Een 3X gehefboomde bitcoin ETF is een bitcoin exchange traded fund dat streeft naar een rendement van drie keer de waarde van de gebruikte index. Hoewel dergelijke ETF’s een hoog rendement hebben, hebben ze ook een hoog risico.</p>
<h3 id="h3-Is20er20een20short20ETF20voor20Bitcoin454424"><a name="Is er een short ETF voor Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er een short ETF voor Bitcoin?</h3><p>Een short ETF voor bitcoin stelt de beleggers in staat om te profiteren wanneer de prijs van bitcoin daalt. De ProShares Short Bitcoin Strategy ETF (BITI) is een voorbeeld van een short ETF voor bitcoin.</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 opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te reproduceren op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>