Q29tZSBsJ2F0dGVzbyBFVEYgQml0Y29pbiBTcG90IGluZmx1aXNjZSBzdWwgbWVyY2F0bw==

2023-11-10, 09:52

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR474425"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>L’approvazione dello spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF rappresentano l’accettazione e il riconoscimento di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> da parte del mondo tradizionale e mainstream, il che contribuirà all’adozione su larga scala di Bitcoin nella realtà, attirando così l’attenzione del mercato.</p>
<p>Al 8 novembre 2023, ci sono circa 20 prodotti ETF Bitcoin spot attivi in tutto il mondo, con un patrimonio totale di $4,16 miliardi.</p>
<p>L’ingresso degli ETF Bitcoin spot è imminente. Di fronte all’eventuale afflusso di enormi fondi, la comunità cripto deve considerare il bilanciamento dell’espansione dei tassi di adozione reale e l’intenzione originale della decentralizzazione.</p>
<h2 id="h2-Introduzione601113"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Alla fine di ottobre, una serie di notizie sul progresso della domanda di ETF Bitcoin spot negli Stati Uniti ha fortemente stimolato la brusca crescita dei prezzi di Bitcoin e ha guidato il trend positivo complessivo del mercato fino ad oggi.</p>
<p>Perché gli ETF spot hanno un impatto così significativo sulla fiducia del mercato, qual è il modello di mercato attuale degli ETF spot e come valutare i vantaggi e gli svantaggi di questo prodotto? L’articolo spiegherà tutte le domande.</p>
<h2 id="h2-Un20viaggio20di201020anni20per20richiedere20ETF20Bitcoin20spot714826"><a name="Un viaggio di 10 anni per richiedere ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un viaggio di 10 anni per richiedere ETF Bitcoin spot</h2><p>L’approvazione degli ETF Bitcoin spot significa l’accettazione e il riconoscimento del Bitcoin da parte del tradizionale mondo mainstream, contribuendo così a una più ampia adozione del Bitcoin nella realtà ed è sempre stato un punto di attenzione del mercato.</p>
<p>La prima domanda di ETF su Bitcoin risale a luglio 2013, quando i co-fondatori di Gemini Cameron e Tyler Winklevoss hanno presentato la loro prima domanda di ETF alla SEC degli Stati Uniti. Ma in quel momento, le agenzie di regolamentazione e persino potenziali investitori non erano molto familiari con le criptovalute e la SEC ha respinto direttamente la domanda, avviando così un viaggio di gioco decennale.</p>
<p>Entro aprile 2019, la notizia dell’approvazione di un ETF Bitcoin si diffuse rapidamente, alimentando notevolmente il mercato ribassista. Sebbene la notizia fosse successivamente falsificata, il sentimento di mercato rimase alto e Bitcoin scatenò una serie di tendenze rialziste quell’anno, indicando l’importante impatto dei prodotti ETF Bitcoin sul mercato.</p>
<p>In realtà, il Grayscale Bitcoin Trust (GBTC), ampiamente conosciuto, che era originariamente un fondo in fase di richiesta di un ETF, è stato convertito in un trust a causa del suo fallimento nel ottenere l’approvazione dalla SEC degli Stati Uniti. Sebbene GBTC non fosse un ETF, era il primo e unico prodotto di investimento in quel momento che poteva essere scambiato sul mercato secondario azionario degli Stati Uniti e seguire il prezzo del Bitcoin, con conseguente premio elevato rispetto al prezzo effettivo del Bitcoin dopo la sua emissione.</p>
<p>Nel mercato rialzista del Bitcoin del 2020, Grayscale è stato in uno stato sovrappeso, diventando un importante indicatore di rialzo del mercato in quel periodo.</p>
<p>Il primo ETF spot al mondo è stato emesso e quotato anche durante questo periodo. Il primo ad essere lanciato è stato il German ETC Group Physical Bitcoin, che è stato negoziato pubblicamente a giugno, seguito dal 3iQ Bitcoin Fund e dal VanEck Bitcoin ETN, lanciati nel quarto trimestre.</p>
<p>Dopo che la richiesta di Grayscale per convertire Bitcoin Trust GBTC in spot ETF è stata respinta nel 2021, l’ETF futures di Bitcoin è stato approvato per l’emissione dalla SEC quell’anno.</p>
<p>In un momento in cui la SEC degli Stati Uniti era preoccupata per la mancanza di trasparenza e liquidità nelle transazioni, nonché per la manipolazione del mercato, che ha portato a un progresso lento, il Canada, il Brasile e altri paesi hanno preso il comando nell’approvazione dell’emissione di ETF Bitcoin spot nell’entusiasmo del mercato rialzista del 2021, contribuendo a far salire significativamente i prezzi del Bitcoin.</p>
<p>Nel 2023, paesi come il Regno Unito e la Germania hanno emesso anche ETF Bitcoin spot e Hong Kong, Cina, ha approvato anche due ETF futures. Tuttavia, la loro scala di negoziazione è troppo piccola e la loro influenza è limitata. L’attenzione del mercato è ancora concentrata sui progressi di molte istituzioni negli Stati Uniti in attesa di approvazione.<img src="https://gimg2.gateimg.com/image/article/169960982914391699609401_.pic.jpg" alt=""><br>Panoramica dei prodotti ETF futures su Bitcoin di CSOP Figura 1 Fonte: csopasset.com</p>
<p>In realtà, dal 2017, basandosi sugli standard per la protezione degli investitori e dell’interesse pubblico, la SEC degli Stati Uniti ha respinto più di dieci richieste per ETF simili, ma le cose stanno subendo cambiamenti positivi.</p>
<p>Dopo ripetuti scontri, l’atteggiamento della SEC degli Stati Uniti nei confronti della revisione ha cominciato a smorzarsi. Da un lato, Grayscale ha vinto la causa contro la SEC e la SEC ha bisogno di rivalutare la richiesta di conversione di Grayscale GBTC. D’altra parte, istituzioni come BlackRock che stanno richiedendo ETF spot hanno iniziato a presentare informazioni sui prodotti presso la Depository and Clearing Corporation (DTCC) degli Stati Uniti, anche se questo non significa che la SEC abbia approvato ufficialmente la richiesta, ma segnali positivi di progresso indicano senza dubbio che l’evento sta per essere completato.</p>
<h2 id="h2-Il20modello20di20mercato20degli20ETF20Bitcoin20Spot200982"><a name="Il modello di mercato degli ETF Bitcoin Spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il modello di mercato degli ETF Bitcoin Spot</h2><p>Al 8 novembre 2023, ci sono circa 20 prodotti attivi di ETF Bitcoin spot in tutto il mondo, con un totale di asset di $4,16 miliardi; Ci sono anche 7 prodotti ETF futures, principalmente situati negli Stati Uniti (5) e a Hong Kong, Cina (2).</p>
<p>Secondo i dati di CoinGecko, su 20 prodotti ETF Bitcoin spot in tutto il mondo, il Canada ne ha 7, che rappresentano quasi il 50% delle dimensioni dell’attivo. Tra questi, il più grande ETF Bitcoin pubblico (BTCC) gestisce quasi 820 milioni di dollari di attività, come dettagliato nella tabella sottostante.<br><img src="https://gimg2.gateimg.com/image/article/1699855251WechatIMG1449.jpg" alt=""><br>Tabella 2 Fonte: CoinGecko</p>
<p>Attualmente, Canada e Europa sono i principali mercati per gli ETF Bitcoin spot.</p>
<p>Il Canada ha il più grande numero di prodotti di questo tipo emessi in precedenza. Il fondo Bitcoin 3iQ del Canada (QBTC) è stato lanciato sul Dubai Nasdaq già nel 2021, portando a una più ampia gamma di fonti di finanziamento.</p>
<p>Dall’ultimo mercato orso dello scorso anno, non vi è stato un aumento significativo delle detenzioni canadesi di BTC in questa categoria di prodotti.</p>
<p>La Germania è stata la prima a emettere ETF Bitcoin spot, con un patrimonio totale di 800 milioni di dollari. Inoltre, altri prodotti europei di questo tipo sono registrati in paradisi fiscali, ma hanno poca influenza nel mercato delle criptovalute come Brasile e Australia, e hanno scarsa incidenza sul mercato delle criptovalute.</p>
<p>Se tutto procede senza intoppi, fino a quando la SEC degli Stati Uniti approva tutte le attuali domande, gli Stati Uniti lanceranno 12 ETF Bitcoin spot entro l’inizio del prossimo anno. Maggiori quantità di prodotto, nonché potenziali enormi fondi, manterranno gli Stati Uniti in alto.</p>
<h2 id="h2-C20la20squadra20di20soccorso20qui20o20c20il20lupo879515"><a name="C’è la squadra di soccorso qui o c’è il lupo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è la squadra di soccorso qui o c’è il lupo?</h2><p>Secondo molti analisti, l’approvazione del fondo negoziato in borsa (ETF) statunitense sul Bitcoin attirerà la partecipazione e l’interesse di molti investitori e istituzioni di trading, contribuirà ad accelerare il tasso di adozione del Bitcoin, aumenterà il valore del Bitcoin e persino dell’intero mercato delle criptovalute, e rappresenterà una pietra miliare importante nello sviluppo del mercato delle criptovalute.</p>
<p>Ad esempio, NYDIG negli Stati Uniti ha affermato che una volta emessi e quotati, la scala della gestione patrimoniale di questi prodotti raggiungerà i 28,8 miliardi di dollari, di cui 27,6 miliardi saranno investiti in prodotti spot.</p>
<p>Bitwise, la più grande società di gestione di fondi indice di valute virtuali al mondo, è più ottimista. Il suo CEO, Matt Hougan, ha dichiarato che se il prodotto può essere approvato, le dimensioni complessive degli ETF Bitcoin spot possono rapidamente raggiungere decine di miliardi di dollari.</p>
<p>Ha stimato che entro cinque anni potrebbe attrarre circa $50 miliardi di fondi, e l’aumento dei prezzi dopo l’andare in pubblico potrebbe ulteriormente espandere la scala.<br><a href="/price/polymath-poly" rel="nofollow noopener noreferrer" target="_blank">prezzo di poli</a><br>Figura 3 Fonte: @Matt_Hougan</p>
<p>Ma non tutti hanno un atteggiamento positivo. Arthur Hayes ritiene che l’afflusso delle istituzioni di Wall Street possa avere un impatto negativo e l’ingresso delle istituzioni finanziarie che rappresentano la volontà nazionale possa manipolare il consenso online e soffocare l’innovazione della comunità.</p>
<p>Ha dichiarato in una colonna che è una domanda discutibile se esse (riferendosi a istituzioni come BlackRock) supporteranno questi aggiornamenti. Ovviamente, quando emergeranno detentori passivi di azioni su larga scala nell’ecosistema, ci sarà più incertezza su questa questione.</p>
<p>Tutto ha due facce. Da un lato, la comunità cripto sta aspettando con impazienza il processo di approvazione del ETF, sperando nella crescita del valore che ne deriva. D’altro canto, la comunità deve pensare attentamente nel lungo termine e cercare piani di risposta efficaci.</p>
<p>L’ingresso degli ETF Bitcoin spot è imminente. Di fronte alla potenziale affluenza di ingenti fondi, come la comunità cripto riuscirà a bilanciare l’espansione dei tassi di adozione reale e il mantenimento delle intenzioni di decentralizzazione potrebbe essere una questione a lungo termine a cui le persone devono prestare attenzione nell’attuale tendenza.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>