UmlwcGxlIENFTyBwcmFhdCBvdmVyIEJUQyBFVEYgZGF0IHppbHZlciBvdmVydHJlZnQgYWxzIGRlIG9wIMOpw6luIG5hIGdyb290c3RlIGludmVzdGVyaW5nc2FjdGl2YQ==

2024-01-31, 03:06

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR574284"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De totale marktwaarde van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s heeft die van zilveren ETF’s overtroffen.</p>
<p>Garlinghouse gelooft dat de cryptobranche bereid is om te voldoen aan nationale crypto-regelgeving.</p>
<p>De SEC was lange tijd niet bereid om de spot goed te keuren <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s uit angst voor marktmanipulatie.</p>
<h2 id="h2-Introductie28642"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel spot bitcoin exchange traded funds op 11 januari in de Verenigde Staten zijn gelanceerd na hun goedkeuring op de 10e, hebben ze veel investeringen aangetrokken tot het punt van het overtreffen van sommige beleggingsactiva die al jaren op de markt zijn.</p>
<p>Bijvoorbeeld, de BTC ETF’s hebben de zilveren ETF’s ingehaald die al jaren op de markt zijn. Dit artikel zal de prestaties van zilveren ETF’s vergelijken met die van spot bitcoin ETF’s. We zullen ook de impact van BTC ETF’s op de cryptomarkt onderzoeken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3698" target="_blank">Goedkeuring van Spot Bitcoin ETF’s wordt een mijlpaal</a></p>
<h2 id="h2-Ripple20CEO20Optimistisch20over20de20prestaties20van20spot20Bitcoin20ETFs522704"><a name="Ripple CEO Optimistisch over de prestaties van spot Bitcoin ETFs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripple CEO Optimistisch over de prestaties van spot Bitcoin ETFs</h2><p>Een paar weken nadat de Amerikaanse SEC spot bitcoin ETF’s heeft goedgekeurd, zijn ze de op één na grootste commodity ETF op de markt geworden na het inhalen van zilveren ETF’s. Wat voornamelijk spot bitcoin ETF’s in staat stelde zilveren ETF’s te overtreffen, is hun aantal. Feit is dat de SEC op dezelfde dag 11 spot bitcoin ETF’s heeft goedgekeurd.</p>
<p>Bovendien heeft de conversie van Grayscale Bitcoin Trust naar een spot BTC ETF geleid tot een plotselinge injectie van bijna $30 miljard in de sector. Dit is veel meer dan de waarde van zilveren ETF’s, die volgens etfdb.com wordt geschat op $11 miljard. Nu is het enige grondstoffen-ETF dat de bitcoin ETF overtreft, goud, met een geschatte totale marktwaarde van ongeveer $95 miljard, verdeeld over 19 ETF’s.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/learn/articles/bitcoin-returns-to-its-golden-path/1563" target="_blank">Keert Bitcoin terug naar zijn gouden pad?</a></p>
<p>In dit verband, <a href="https://twitter.com/OpheliaBSnyder/status/1748071064578466083" rel="nofollow noopener noreferrer" target="_blank">Ophelia Snyder, medeoprichter van 21Shares -</a> die in samenwerking met Ark Invest een van de 11 spot BTC lanceerde, zei: ‘Dit overtrof mijn korte termijn verwachting, maar het is een fantastische bevestiging van de rol van bitcoin als reserveproduct en van de vraag naar blootstelling aan bitcoin op financiële markten.’</p>
<p>De goedkeuring van de bitcoin ETF door de SEC markeerde een van de grootste ontwikkelingen in de sector sinds de oprichting van de blockchain. De betekenis van de bitcoin ETF’s werd aangetoond door een netto instroom van $894 miljoen binnen de eerste drie dagen na de lancering ervan.</p>
<p>Brad Garlinghouse, CEO van Ripple, blijft optimistisch over de recent gelanceerde bitcoin ETF’s. In feite stelt de goedkeuring van de bitcoin ETF investeerders in staat om blootstelling aan BTC te krijgen zonder de moeite van het kopen en vasthouden ervan.</p>
<p>In feite legde Garlinghouse uit dat hij een reden heeft om er zeker van te zijn dat BTC ETF’s het in de toekomst goed zullen doen. Hij commentarieerde over X. <a href="https://twitter.com/morningsmaria/status/1747979054874067159?s=46&amp;t=3iAFD_WHRWDFSLixlrJyWg" rel="nofollow noopener noreferrer" target="_blank">zei hij</a> Het is een zeer grote zaak, grotendeels is het verdere validatie van instellingen, en in dit g, een overheidsinstantie. De lancering van deze crypto-ETF’s zal grote instellingen in staat stellen te investeren in bitcoin.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3728/what-does-bitcoin-etf-introduction-mean-for-investors" target="_blank">Wat betekent de introductie van Bitcoin ETF voor investeerders</a></p>
<h2 id="h2-De20cryptoindustrie20is20toegewijd20aan20regelgevende20naleving20Garlinghouse597211"><a name="De crypto-industrie is toegewijd aan regelgevende naleving: Garlinghouse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De crypto-industrie is toegewijd aan regelgevende naleving: Garlinghouse</h2><p>Afgezien van zijn onwrikbare <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> bij spot bitcoin ETF’s benadrukte Garlinghouse dat de crypto-industrie bereid is om te voldoen aan crypto-regelgeving, ongeacht waar deze wordt ingevoerd en gehandhaafd.</p>
<p>Hij heeft commentaar gegeven op verschillende landen, waaronder Japan, Zwitserland en het Verenigd Koninkrijk, voor het creëren van duidelijke crypto-regels die voorschrijven hoe investeerders en crypto-bedrijven zich moeten gedragen.<br><img src="https://gimg2.gateimg.com/image/article/1706670242At299zNsy9.jpg" alt=""><br>Bron: X.com</p>
<p>Ondanks zijn optimisme over de bloei van bitcoin ETF’s in de Verenigde Staten en de rest van de wereld, heeft Garlinghouse kritiek geuit op de manier waarop de Amerikaanse overheidsregulatoren het bitcoin ETF-proces hebben afgehandeld.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/a-comprehensive-analysis-of-key-information-on-btc-spot-etfs/1576" target="_blank">Een uitgebreide analyse van belangrijke informatie over BTC Spot Bitcoin ETF</a></p>
<p>Dit komt doordat Garlinghouse van mening is dat toezichthouders de cryptoregels en andere nationale beleidsmaatregelen moeten afstemmen op het algemeen belang. Zijn kritiek is nu dat de Amerikaanse overheidsregulatoren er niet in slagen om de cryptowetten af te stemmen op de belangen van het publiek en de opkomende wereldwijde trend.</p>
<p>Zijn perspectief is dat vanwege de gedecentraliseerde aard van digitale activa zoals cryptocurrencies het het beste is voor landen om hun crypto-regelgeving op elkaar af te stemmen om een ​​synergetisch en effectief juridisch systeem te creëren dat innovatie bevordert en investeerders beschermt. De opmerkingen van Garlinghouse volgen op het <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">langdurige SEC tegen uitstel van goedkeuring van spot bitcoin ETF</a>.</p>
<h2 id="h2-Wat20is20een20Spot20Bitcoin20ETF774315"><a name="Wat is een Spot Bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een Spot Bitcoin ETF?</h2><p>We hebben de optimisme van Garlinghouse besproken over spot bitcoin ETFs. Ook hebben we gekeken naar hoe de bitcoin ETFs qua totale marktwaarde de zilveren ETFs hebben ingehaald. Laten we nu kort ingaan op wat bitcoin ETFs zijn?</p>
<p>Een spot bitcoin ETF is een exchange traded fund dat de waarde van bitcoin volgt. Wat dit betekent is dat als er geen markt <a href="https://www.gate.io/learn/articles/the-imminent-decision-by-the-us-sec-on-bitcoin-etfs-and-its-potential-impact-on-bitcoin-prices/1572" target="_blank">Het manipuleren van de Bitcoin-prijs zou moeten correleren met de waarde van de aandelen die een Bitcoin ETF vormen</a>.</p>
<p>Een spot bitcoin ETF stelt beleggers in staat blootstelling aan bitcoin te krijgen zonder de risico’s van het vasthouden ervan. Spot bitcoin ETF’s worden echter alleen verhandeld op traditionele aandelenbeurzen, niet op crypto-beurzen. Het is ook vermeldenswaard dat spot BTC ETF’s gereguleerde beleggingsactiva zijn, een reden waarom ze veel beleggers aantrekken.</p>
<h2 id="h2-Hoe20benvloeden20BTC20ETFs20de20cryptomarkt276048"><a name="Hoe beïnvloeden BTC ETF’s de cryptomarkt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe beïnvloeden BTC ETF’s de cryptomarkt?</h2><p>De spot bitcoin ETF’s zullen veel traditionele beleggers, waaronder grote instellingen, in staat stellen om te investeren in het crypto-activum. De reden hiervoor is dat de ETF’s worden aangeboden op traditionele aandelenbeurzen waar veel beleggers andere activa zoals aandelen bezitten. Zo bieden bijvoorbeeld bedrijven als BlackRock en Fidelity, die bekende namen zijn in de sector, spot bitcoin ETF’s aan.</p>
<p>Ten tweede zal de goedkeuring van BTC ETF-aanvragen helpen om de liquiditeit op de bitcoin-markt te vergroten. Een dergelijke toename van de liquiditeit zal efficiënt handelen mogelijk maken voor zowel kleine als grote beleggers.</p>
<p>Op dezelfde manier kan de toename van liquiditeit en handelsvolume ook leiden tot efficiënte prijsontdekking, wat helpt om de volatiliteit van het crypto-activum te stabiliseren. Als gevolg daarvan zal dit leiden tot een stabiele bitcoin-markt die meer investeerders zal aantrekken.</p>
<p>De bullish momentum die de bitcoin ETF’s kunnen handhaven, zou de groei van de cryptosector kunnen vergemakkelijken. In feite kan het optimisme dat momenteel in de bitcoinmarkt bestaat, BTC-investeringen demystificeren en de groei van de industrie stimuleren. Kortom, de spot bitcoin ETF’s hebben bitcoin gelegitimeerd in de ogen van langdurige pessimisten.</p>
<p>Op de lange termijn kunnen spot bitcoin ETF’s indirect leiden tot een aanhoudende stijging van de BTC-prijs. Dit komt doordat de lancering van de crypto-ETF’s zal leiden tot een grotere adoptie van bitcoin, aangezien een diverse groep mensen erin investeert. Sommige bedrijven zullen er vertrouwen in hebben om het als betaalmiddel voor goederen en diensten te accepteren. Het is de toenemende vraag naar BTC die zal leiden tot een stijging van de prijs.</p>
<p>Verder zal de lancering van de spot BTC ETF’s de publieke kennis over bitcoin en andere cryptocurrencies vergroten via de media en investeringsfora, onder andere. Dit kan helpen om de adoptie ervan te vergroten.</p>
<p>De goedkeuring van bitcoin ETF’s kan de regelgevende duidelijkheid in de sector vergroten. Zo heeft de Amerikaanse SEC de spot bitcoin ETF aangewezen als een commodity ETF. Dit heeft inderdaad bevestigd dat bitcoin een commodity is in plaats van een effect. Op dezelfde manier, als de SEC een spot ETH ETF goedkeurt, kan dat ook ETH wettelijk onderschrijven als een commodity.</p>
<h2 id="h2-Hoe20correleert20de20waarde20van20de20Bitcoin20ETF20met20de20BTCprijs444035"><a name="Hoe correleert de waarde van de Bitcoin ETF met de BTC-prijs?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe correleert de waarde van de Bitcoin ETF met de BTC-prijs?</h2><p>De uitgevers van bitcoin ETF’s hebben een systeem om ervoor te zorgen dat de prijs van bitcoin correleert met de waarde van de ETF’s. Specifiek zou de waarde van de uitgegeven ETF-aandelen van een bedrijf moeten overeenkomen met het aantal bitcoins dat het in bezit heeft.</p>
<p>Om de waarden van de aandelen af te stemmen op het aantal munten dat het heeft en om te reflecteren op de heersende bitcoin marktwaarde, zal de uitgever voortdurend het actief verkopen of kopen. Sommige geautoriseerde deelnemers (AP’s), die grote financiële instellingen zijn, vergemakkelijken het creatie- en terugbetalingsproces. Ook zorgen sommige marktmakers ervoor dat er evenwicht is op de ETF-markt door het kopen en verkopen van ETF-aandelen.</p>
<h2 id="h2-Waarom20was20de20SEC20tegen20Spot20Bitcoin20ETFs310288"><a name="Waarom was de SEC tegen Spot Bitcoin ETF’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom was de SEC tegen Spot Bitcoin ETF’s?</h2><p>De SEC toonde lange tijd reserves over het goedkeuren van spot bitcoin ETF’s. Het vreesde marktmanipulatie die investeerders bloot zou kunnen stellen aan financiële risico’s.</p>
<p>De toezichthouders van de Amerikaanse overheid waren ook bezorgd over de opkomende aard van de cryptomarkt. Daarom wilde de SEC de investeerders beschermen en tegelijkertijd innovatie bevorderen. Ook kan het feit dat de cryptomarkt destijds nog niet volwassen was invloed hebben gehad op het gedrag van de SEC.</p>
<p>Concentratie van het bezit van bitcoin in handen van een paar investeerders (haaien en walvissen) en arbitrage tussen de prijzen van bitcoin en de ETF’s zijn manieren waarop marktmanipulatie kan plaatsvinden.</p>
<h2 id="h2-Conclusie359134"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De marktwaarde van spot bitcoin ETF’s is hoger dan die van zilveren ETF’s, wat optimisme creëert in de cryptomarkt. Bovendien heeft de lancering van de ETF’s geholpen om bitcoin te ontrafelen, wat veel investeerders naar de sector kan trekken. Nu is het belangrijk voor de BTC-uitgevers, market makers, geautoriseerde deelnemers (AP’s) en beurzen om ervoor te zorgen dat er geen marktmanipulatie plaatsvindt.</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 mening 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 zal worden toegestaan mits naar Gate.io wordt verwezen. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>