SlBNb3JnYW4gcHJldmVkZSBkZWZsdXNzaSBkaSAyLDcgbWlsaWFyZGkgZGkgZG9sbGFyaSBkYWxsYSBjb252ZXJzaW9uZSBkZWxsJ0VURiBHQlRD

2023-12-07, 08:59

<p><img src="https://gimg2.gateimg.com/image/article/1701938930RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR846425"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Gli analisti di JPMorgan prevedono che ci saranno almeno $2,7 miliardi di deflussi dopo la conversione dell’ETF.</p>
<p>Una grande fuoriuscita dopo la conversione dell’ETF potrebbe portare a un forte calo del valore di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>L’accordo di Binance porta alla chiusura dell’indagine statunitense sulla borsa che durava da un anno.</p>
<h2 id="h2-Introduzione725509"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il valore del <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc &quot;Grayscale Bitcoin Trust (GBTC" rel="nofollow noopener noreferrer" target="_blank">Fiducia Bitcoin Grayscale (GBTC)</a> Le azioni di “) sono aumentate significativamente dopo che la Securities and Exchange Commission (SEC) degli Stati Uniti non ha fatto appello contro la sentenza della Corte d’Appello del Distretto di Columbia, che le ha ordinato di rivedere l’applicazione <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> di Grayscale Spot.</p>
<p>Come il <a href="https://www.gate.io/blog_detail/3357/analyzing-the-sec-s-appeal-and-its-impact-on-grayscale-bitcoin-etf-ruling" target="_blank">La SEC sta rivalutando la richiesta di Grayscale per l’applicazione di Bitcoin spot</a> Molti investitori hanno mostrato grande interesse per le azioni del Grayscale Bitcoin Trust (GBTC). Le aspettative del mercato per l’approvazione della domanda di Grayscale BTC ETF hanno attirato gli investitori ad acquistare le sue azioni GBTC, attualmente in negoziazione con uno sconto del 10%. Questo articolo analizza le possibili fuoriuscite quando GBTC si converte in un ETF, se la SEC approva l’ETF di bitcoin spot di Grayscale.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/gbtc-bitcoin-discount-nav" target="_blank">GBTC vs Bitcoin: vale la pena lo sconto sul NAV?</a></p>
<h2 id="h2-Gli20analisti20prevedono20un20deflusso20di202720miliardi20di20dollari20quando20GBTC20si20converte20in20ETF663118"><a name="Gli analisti prevedono un deflusso di 2,7 miliardi di dollari quando GBTC si converte in ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli analisti prevedono un deflusso di 2,7 miliardi di dollari quando GBTC si converte in ETF</h2><p>Gli analisti di JPMorgan pensano che i trader di GBTC potrebbero incassare dopo la sua conversione in ETF. Credono che gli investitori possano vendere azioni GBTC per un valore di 2,7 miliardi di dollari. Tuttavia, ciò dipenderà dai flussi in entrata delle azioni a partire dal 2023.</p>
<p>JPMorgan ha fatto questa valutazione in quanto prevede che Grayscale Bitcoin Trust lo sia <a href="https://www.gate.io/blog_detail/3424/how-the-highly-anticipated-spot-bitcoin-etf-impacts-the-market" target="_blank">convertito in un ETF bitcoin spot nel 2024</a>. Dal momento che l’ETF - GBTC è scambiato al di sotto del valore dell’attivo netto (NAV) una volta che la SEC lo approva, i trader speculativi potrebbero essere in grado di trarre profitto dalla differenza tra il prezzo attuale e il NAV.</p>
<p>La possibilità dello scenario sopra descritto ha creato preoccupazione per JPMorgan in quanto teme un potenziale ritiro di oltre $2,7 miliardi. Un così grande deflusso è probabile che spinga il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> giù.</p>
<p>Tuttavia, i 2,7 miliardi di dollari potrebbero trovare la loro strada di nuovo negli strumenti correlati al bitcoin, in particolare negli spot BTC ETF. Se i fondi <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> in altri spot bitcoin ETF che potrebbero mitigare eventuali effetti negativi sul prezzo del bitcoin. In generale, tuttavia, c’è un’alta possibilità di un calo del prezzo del BTC dopo la conversione dell’ETF.</p>
<p>È importante notare che gli investitori di GBTC hanno acquistato l’asset con uno sconto del 10%. Ciò significa semplicemente che il valore di GBTC è inferiore del 10% rispetto al prezzo di mercato di bitcoin. È importante notare che GBTC era scambiato con uno sconto inferiore al 10% a partire da luglio di quest’anno. Dall’inizio dell’anno lo sconto era di circa il 46%.</p>
<p>L’altro motivo principale per cui le azioni GBTC sono state scambiate con uno sconto è che gli investitori non possono riscattarle. Invece, possono venderle ad altri potenziali acquirenti. Prima di luglio 2021 le azioni venivano scambiate a un premio, ma sono state negative influenzate dalla stretta del credito che si è verificata in quel periodo.</p>
<p>Quel brusco calo dello sconto mostra che gli investitori si aspettano un’approvazione ETF all’inizio dell’anno prossimo. Inoltre, i calcoli di JPMorgan si basavano sull’assunzione che gli investitori avessero acquistato il GBTC a fini speculativi. Sullo stesso argomento, il Grayscale Bitcoin Trust dovrebbe abbassare le sue commissioni per ridurre l’ammontare degli deflussi e mantenere la sua predominanza sul mercato.</p>
<p><a href="https://www.gate.io/article/18495" target="_blank">Grayscale GBTC</a> Le commissioni dovrebbero corrispondere a quelle dell’ARK 21Shares Bitcoin ETF, attualmente pari all’80 punti base. Nel frattempo, la commissione attuale del GBTC è pari a 200 punti base. A riguardo, gli analisti di JPMorgan hanno ipotizzato che l’approvazione di una richiesta di ETF di bitcoin spot possa portare a una forte concorrenza con altri prodotti di investimento in bitcoin, il che potrebbe determinare una netta diminuzione delle commissioni.</p>
<h2 id="h2-Linsediamento20di20Binance20con20le20agenzie20degli20Stati20Uniti2020un20sviluppo20positivo20per20lo20scambio20e20lindustria343967"><a name="L’insediamento di Binance con le agenzie degli Stati Uniti è un sviluppo positivo per lo scambio e l’industria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’insediamento di Binance con le agenzie degli Stati Uniti è un sviluppo positivo per lo scambio e l’industria</h2><p><a href="https://www.theblock.co/amp/post/264283/jpmorgan-binance-settlement-positive-crypto" rel="nofollow noopener noreferrer" target="_blank">Come per il blocco</a>, Nikolaos Panigirtzoglou, un analista di spicco presso JPMorgan, ha affermato che l’accordo tra Binance e le agenzie statunitensi è positivo per l’intero settore in quanto ha ridotto l’incertezza che circonda l’exchange.</p>
<p>In primo luogo, Panigirtzoglou ha detto che il regolamento potrebbe aiutare a mantenere alto il volume degli scambi sulla borsa. <a href="https://www.theblock.co/amp/post/264283/jpmorgan-binance-settlement-positive-crypto" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Vediamo la prospettiva della risoluzione positivamente in quanto l’incertezza intorno a Binance stessa diminuirebbe e la sua attività di trading e” <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> La catena intelligente del business ne trarrebbe beneficio.</p>
<p>Ha spiegato ulteriormente: “Per gli investitori cripto, la prospettiva di un accordo comporterebbe l’eliminazione di un potenziale rischio sistemico derivante da un ipotetico crollo di Binance”.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">Gli ETF Bitcoin Spot possono diventare catalizzatori di mercato se approvati?</a></p>
<p>Anche se Binance dovrà pagare $4 miliardi come parte dell’accordo, ci sarà una conclusione sul caso. Ciò consente anche allo scambio di continuare le operazioni come prima. Fondamentalmente, questo accordo ha concluso un’indagine legale durata un anno sulle operazioni di Binance.</p>
<p>Dopo la liquidazione, il ruolo più immediato del nuovo CEO di Binance, Richard Teng, è assicurare ai clienti dell’exchange che tutto è sotto controllo e che dovrebbero rimanere calmi.</p>
<p>Attraverso X, <a href="https://twitter.com/_RichardTeng/status/1727066202047164562" rel="nofollow noopener noreferrer" target="_blank">Teng ha rassicurato i clienti</a> che lavorerà a fianco dei regolatori statunitensi per spingere avanti l’exchange Binance. Ha scritto: “Il mio obiettivo sarà:”</p>
<p>1) Rassicurare gli utenti che possono rimanere fiduciosi nella solidità finanziaria, sicurezza e sicurezza dell’azienda</p>
<p>2) Collaborare con i regolatori per sostenere elevati standard a livello globale che favoriscano l’innovazione garantendo nel contempo importanti protezioni per i consumatori</p>
<p>3) Lavorare con i partner per stimolare la crescita e l’adozione di Web3.</p>
<h2 id="h2-Conclusione440665"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Gli analisti di investimento di JPMorgan hanno previsto che GBTC subirà almeno 2,7 miliardi di uscite dopo la conversione dell’ETF. L’ipotesi è che la maggior parte degli investitori di GBTC abbia acquistato le azioni per scopi speculativi poiché venivano vendute con uno sconto inferiore al 10%. Le grandi uscite da GBTC potrebbero comportare una forte diminuzione del valore di bitcoin.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </strong>, Ricercatore di Gate.io<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. Il ripostaggio dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno adottate azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>