Vm9vcnN0ZWwgdmFuIEdyYXlzY2FsZSB6ZXQgU0VDIGFhbiB0b3QgaGVyb3ZlcndlZ2luZyB2YW4gQml0Y29pbiBFVEYncw==

2023-12-29, 08:46

<p><img src="https://gimg2.gateimg.com/image/article/1703838812RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen813191"><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 SEC zal waarschijnlijk een meer meegaande houding aannemen ten opzichte van spot. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s als gevolg van de recente gerechtelijke uitspraak.</p>
<p>Op dit moment ueert de SEC tussen 8 en 12 spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s.</p>
<p>Het is waarschijnlijk dat de SEC in januari 2024 verschillende spot bitcoin ETF’s zal goedkeuren.</p>
<h2 id="h2-Introductie517499"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel veel analisten verwachten dat <a href="https://www.gate.io/blog_detail/3611/daily-news-the-sec-announced-the-deadline-for-bitcoin-spot-etfs-application-solana-s-network-activity-data-achieved-a-record-high-bitcoin-halving-time-is-less-than-120-days" target="_blank">de SEC zal naar verwachting spot bitcoin ETF’s goedkeuren tijdens het eerste kwartaal van 2024</a> Daar is geen garantie voor. Het lijkt erop dat de SEC van de Verenigde Staten streng blijft op haar eisen voor de goedkeuring van spot BTC ETF’s. De SEC heeft vergaderingen gehouden met de toekomstige <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">bitcoin ETF</a> uitgevers.</p>
<p>Vandaag kijken we naar het huidige standpunt van de SEC over spot bitcoin na de beslissing van de Grayscale-rechtbank die de regelgevende instantie heeft gedwongen haar eisen aan de goedkeuring van de spot BTC ETF’s te heroverwegen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3555/grayscale-pushes-spot-btc-etf" target="_blank">Grayscale gaat door met de Spot Bitcoin ETF</a></p>
<h2 id="h2-Standpunt20van20de20SEC20na20de20Grayscalerechtszaak20over20de20goedkeuring20van20een20Spot20Bitcoin20ETF365296"><a name="Standpunt van de SEC na de Grayscale-rechtszaak over de goedkeuring van een Spot Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Standpunt van de SEC na de Grayscale-rechtszaak over de goedkeuring van een Spot Bitcoin ETF</h2><p>Gary Gensler, de voorzitter van de Amerikaanse Securities and Exchange Commission (SEC), heeft gehint op een verandering in zijn standpunt ten aanzien van spot bitcoin ETF’s als gevolg van de uitspraak van de rechtbank over de aanvraag van Grayscale ETF.</p>
<p>Het is zeer waarschijnlijk dat de SEC een mildere houding zal aannemen ten opzichte van een spot bitcoin ETF dan voorheen. Desalniettemin heeft het nog niet bevestigd welke richting het in de toekomst zal inslaan. In een interview met CNBC op 14 dec. <a href="https://www.cnbc.com/video/2023/12/14/sec-chair-gary-gensler-ai-is-the-most-transformative-technology-of-our-time.html" rel="nofollow noopener noreferrer" target="_blank">Gensler zei</a> dat de SEC momenteel tussen de acht en twaalf aanvragen afhandelt.</p>
<p>Gensler onthulde dat de toezichthoudende autoriteit voorheen ETF-aanvragen had afgewezen, maar dat de rechtbanken hebben ingegrepen. Hij zei: ‘We hebben in het verleden een aantal van deze aanvragen afgewezen. Dus we kijken hier opnieuw naar op basis van die gerechtelijke uitspraken.’</p>
<p>Zoals je opmerkt, suggereren zijn woorden een verandering van focus. Desalniettemin, <a href="https://www.cnbc.com/video/2023/12/14/sec-chair-gary-gensler-ai-is-the-most-transformative-technology-of-our-time.html" rel="nofollow noopener noreferrer" target="_blank">Hij benadrukte</a> dat wat het regelgevende orgaan heeft gedaan, wordt geleid door ‘de wetten die het Congres heeft aangenomen en hoe de rechtbanken ze interpreteren’.</p>
<p>Iets unieks aan Gensler, de SEC-voorzitter, is dat hij vaak het beantwoorden van bepaalde vragen op een directe manier negeert. In een interview met Kailey Leinz van Bloomberg op 14 december ontweek hij bijvoorbeeld een vraag over het aantal vullingen voor spot bitcoin ETF’s.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">Kunnen Spot Bitcoin ETF’s marktkatalysatoren worden als ze worden goedgekeurd?</a></p>
<p>Als gevolg hiervan gaf Bryan Steil een openhartige opmerking over X over de gebruikelijke reactie van Gensler op vragen. <a href="https://twitter.com/RepBryanSteil/status/1735032072425676838" rel="nofollow noopener noreferrer" target="_blank">Steil geplaatst</a>“Voorzitter Gary Gensler verhult cryptografie bij de pers zoals hij dat doet tijdens commissievergaderingen. Hij wil zijn agressieve regulerende aanpak van zijn bureau niet uitleggen, wat de cryptografie naar het buitenland duwt.”</p>
<h2 id="h2-Afgewezen20aanvragen20voor20Spot20Bitcoin20ETFs844226"><a name="Afgewezen aanvragen voor Spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Afgewezen aanvragen voor Spot Bitcoin ETF’s</h2><p>De SEC heeft de verschillende aanvragen voor spot bitcoin ETF’s die het in het verleden heeft ontvangen, waaronder het aanbod van Grayscale Investment via zijn Bitcoin Trust, afgewezen. Opmerkelijk is dat de SEC de aanvraag voor spot bitcoin van Grayscale heeft afgewezen op basis van het feit dat het niet voldoende heeft aangegeven hoe het investeerders zal beschermen tegen marktmanipulatie.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3461" target="_blank">Spotlight op Spot Bitcoin ETF’s en hun impact</a></p>
<p>Na de beslissing van de SEC om de aanvraag af te wijzen, heeft Grayscale de toezichthoudende autoriteit aangeklaagd op basis van het feit dat zij in het verleden ook futures-gebaseerde ETF’s heeft goedgekeurd die afhankelijk zijn van de prijs van bitcoin.</p>
<p>Uiteindelijk oordeelde de rechtbank dat de SEC willekeurig de aanvraag van Grayscale voor een spot bitcoin exchange traded fund afwees, omdat het niet uitlegde hoe de op futures gebaseerde ETF en Spot BTC ETF materieel verschillen.</p>
<p>De zaak Grayscale SEC werd interessant toen de toezichthoudende instantie weigerde in beroep te gaan tegen die uitspraak. Daarom wacht de cryptomarkt af om te zien wat de volgende zet van de SEC zal zijn, gezien er meer dan 8 ETF-aanvragen zijn, waaronder die van BlackRock, Invesco, Galaxy, VanEck, Valkyrie en Fidelity. Desalniettemin heeft de SEC nog geen beslissing genomen over de aanvragen van deze vermogensbeheerders.</p>
<h2 id="h2-SEC20Ontmoet20Spot20Bitcoin20ETF20Uitgevers20om20een20Weg20Voorwaarts20te20Bepalen563454"><a name="SEC Ontmoet Spot Bitcoin ETF Uitgevers om een Weg Voorwaarts te Bepalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC Ontmoet Spot Bitcoin ETF Uitgevers om een Weg Voorwaarts te Bepalen</h2><p>In de afgelopen twee maanden heeft de Amerikaanse Securities and Exchange Commission gesprekken gevoerd met verschillende potentiële uitgevers van spot bitcoin ETF’s, waaronder Blackrock, Fidelity, Franklin Templeton en Grayscale, om kwesties te bespreken die verband houden met<br><strong>SEC keurt spot bitcoin ETF’s goed.</strong>”</p>
<p>Onlangs heeft de SEC op 8 december vergaderd met Grayscale en Franklin Templeton. Ook heeft het op respectievelijk 7 en 11 december vergaderingen gehad met Fidelity Investments en BlackRock. Daarom merkte Eric Balchunas, een senior Bloomberg ETF-analist, op dat de SEC druk bezig is met X.</p>
<p><a href="https://twitter.com/EricBalchunas/status/1734688272293789759" rel="nofollow noopener noreferrer" target="_blank">Hij schreef</a>“De SEC is drukker dan de elfjes van de Kerstman. Blackrocks derde bijeenkomst met hen gisteren is naar mijn mening het meest opmerkelijk, omdat iedereen wacht om te zien of ze de SEC kunnen overtuigen om in-kind creaties toe te staan in de eerste ronde van goedkeuringen.</p>
<p>Niets baanbrekends te melden, maar 4 verschillende uitgevers hebben contact gehad met de SEC met betrekking tot hun Bitcoin ETF-aanvragen.</p>
<p><a href="https://twitter.com/JSeyff/status/1734679896746758219?ref_src=twsrc%5Etfw" rel="nofollow noopener noreferrer" target="_blank">James Seyffart, nog een ETF-analist van Bloomberg, zei</a>, ‘Zowel de [SEC] Division of Trading &amp; Markets als de Division of Corporate Finance waren aanwezig bij elk van deze vergaderingen. Dit zijn de twee divisies die uiteindelijk zullen beslissen of &amp; wanneer de 19b-4’s &amp; S-1’s zullen worden goedgekeurd of afgewezen.’</p>
<h2 id="h2-Onderhandelingen20van20Grayscale20met20SEC662578"><a name="Onderhandelingen van Grayscale met SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderhandelingen van Grayscale met SEC</h2><p>Hoewel het lijkt alsof er vertragingen zijn bij de goedkeuring van bitcoin ETF’s, groeit de speculatie in de crypto-sector dat de SEC ze al in januari 2024 zal goedkeuren. Wat lijkt het struikelblok te zijn, is het model dat moet worden gebruikt.</p>
<p>De SEC heeft de voorkeur voor het cashcreatiemodel, terwijl de meeste potentiële uitgevers van spot bitcoin de voorkeur geven aan het in-kind creatiemodel voor spot bitcoin ETF’s. Sommige uitgevers van spot BTC ETF’s, zoals BlackRock, zijn bereid om hun in-kind model te herzien.</p>
<h2 id="h2-Conclusie670252"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De SEC heeft gezegd dat het bereid is om zijn standpunt over spot bitcoin ETF-aanvragen opnieuw te ueren in het licht van de recente Grayscale rechtbankuitspraak. Tot nu toe overweegt de SEC tussen de 8 en een dozijn ETF-aanvragen. Ondertussen verwacht de markt dat de SEC begin januari 2024 verschillende spot bitcoin ETF’s zal goedkeuren.</p>
<h2 id="h2-Veelgestelde20vragen20over20Spot20Bitcoin20ETFs561099"><a name="Veelgestelde vragen over Spot Bitcoin ETFs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Spot Bitcoin ETFs</h2><h3 id="h3-Wat20is20Grayscale524973"><a name="Wat is Grayscale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Grayscale?</h3><p>Grayscale is een toonaangevende cryptocurrency vermogensbeheerder gevestigd in de Verenigde Staten. Het biedt beleggingsactiva die blootstelling geven aan digitale activa zoals cryptocurrencies. Onlangs, <a href="https://www.gate.io/blog_detail/3357/analyzing-the-sec-s-appeal-and-its-impact-on-grayscale-bitcoin-etf-ruling &quot;Grayscale filed an application for the launch of a spot bitcoin exchange traded fund (ETF" rel="nofollow noopener noreferrer" target="_blank">Grayscale heeft een aanvraag ingediend voor de lancering van een spot-bitcoin exchange traded fund (ETF).</a>.”)</p>
<h3 id="h3-Wat20is20spot20bitcoin20ETF997515"><a name="Wat is spot bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is spot bitcoin ETF?</h3><p>Een spot bitcoin ETF is een crypto-derivaat dat de prijs van bitcoin volgt. Het stelt investeerders in staat blootstelling aan bitcoin te krijgen zonder het te bezitten. Momenteel zijn er geen spot bitcoin ETF’s in de Verenigde Staten.</p>
<h3 id="h3-Wat20zijn20crypto20ETFs906735"><a name="Wat zijn crypto ETF’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn crypto ETF’s?</h3><p>Crypto ETF’s zijn beleggingsactiva die investeerders blootstelling geven aan cryptocurrencies zonder deze te bezitten. De aandelen van crypto ETF’s worden verhandeld op traditionele aandelenmarkten.</p>
<h3 id="h3-SEC20vs20Crypto20ETFs20Wie20wint20de20strijd883202"><a name="SEC vs. Crypto ETFs- Wie wint de strijd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC vs. Crypto ETFs- Wie wint de strijd?</h3><p>De SEC neemt de tijd om de geschiktheid van crypto-ETF’s te beoordelen. Het heeft in het laatste kwartaal van 2023 gesprekken gevoerd met potentiële spot bitcoin-uitgevers. Op dit moment is het zeer waarschijnlijk dat de Amerikaanse SEC begin 2024 verschillende crypto-ETF’s zal goedkeuren.</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 visie van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>