SWwgQ0VPIGRpIFJpcHBsZSBwYXJsYSBkZWxsJ0VURiBCVEMgY2hlIHN1cGVyYSBsJ2FyZ2VudG8gY29tZSBzZWNvbmRvIHBpw7kgZ3JhbmRlIGFzc2V0IGRpIGludmVzdGltZW50bw==

2024-01-31, 03:06

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR750645"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il valore di mercato totale degli ETF di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha superato quello degli ETF d’argento.</p>
<p>Garlinghouse ritiene che l’industria delle criptovalute sia disposta a conformarsi alle normative nazionali sulle criptovalute.</p>
<p>Per molto tempo la SEC non era disposta ad approvare spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF a causa della paura della manipolazione del mercato.</p>
<h2 id="h2-Introduzione99111"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Anche se i fondi negoziati in borsa di bitcoin sono stati lanciati negli Stati Uniti l’11 gennaio dopo la loro approvazione il 10, hanno attratto molti investimenti al punto da superare alcuni asset di investimento che sono stati sul mercato per anni.</p>
<p>Ad esempio, gli ETF BTC hanno superato gli ETF Silver che sono stati sul mercato per anni. In questo articolo verrà confrontata la performance degli ETF Silver con quella degli ETF Bitcoin spot. Esploreremo anche l’impatto degli ETF BTC sul mercato delle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3698" target="_blank">L’approvazione degli ETF di Bitcoin spot diventa una pietra miliare</a></p>
<h2 id="h2-Il20CEO20di20Ripple20ottimista20sulle20prestazioni20degli20ETF20Bitcoin20spot219171"><a name="Il CEO di Ripple ottimista sulle prestazioni degli ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CEO di Ripple ottimista sulle prestazioni degli ETF Bitcoin spot</h2><p>Pochi settimane dopo che la SEC degli Stati Uniti ha approvato gli ETF bitcoin spot, sono diventati il secondo ETF di materie prime più grande del mercato dopo aver superato gli ETF dell’argento. Ciò che ha permesso agli ETF bitcoin spot di superare gli ETF dell’argento in modo principale è il loro numero. Come fatto, la SEC ha approvato 11 ETF bitcoin spot nello stesso giorno.</p>
<p>Inoltre, la conversione del Grayscale Bitcoin Trust in un ETF BTC spot ha comportato un’improvvisa iniezione di quasi 30 miliardi di dollari nel settore. Questo è molto più del valore degli ETF dell’argento stimato in 11 miliardi di dollari, secondo etfdb.com. Adesso, l’unico ETF di materie prime che supera l’ETF del bitcoin è l’oro con un valore di mercato totale stimato intorno ai 95 miliardi di dollari, distribuito su 19 ETF.</p>
<p>Articolo correlato: <a href="https://www.gate.io/learn/articles/bitcoin-returns-to-its-golden-path/1563" target="_blank">Il Bitcoin ritorna sulla sua strada d’oro?</a></p>
<p>A tal fine, <a href="https://twitter.com/OpheliaBSnyder/status/1748071064578466083" rel="nofollow noopener noreferrer" target="_blank">Ophelia Snyder, co-fondatrice di 21Shares -</a> che in partnership con Ark Invest ha lanciato uno dei 11 spot BTC - ha detto: ‘Questa è stata molto al di là delle mie aspettative a breve termine, ma è una fantastica convalida del ruolo di bitcoin come prodotto di riserva e della domanda di esposizione a bitcoin nei mercati finanziari.’</p>
<p>Significativamente, l’approvazione del bitcoin ETF della SEC ha segnato uno dei più grandi sviluppi nel settore sin dalla creazione della blockchain. La rilevanza dei bitcoin ETF è stata dimostrata da un afflusso netto di 894 milioni di dollari nei primi tre giorni del loro lancio.</p>
<p>Brad Garlinghouse, CEO di Ripple, rimane ottimista riguardo agli ETF di bitcoin recentemente lanciati. Fondamentalmente, l’approvazione degli ETF di bitcoin consente agli investitori di ottenere esposizione a BTC senza il fastidio di acquistarlo e tenerlo.</p>
<p>In realtà, Garlinghouse ha spiegato una ragione per cui è sicuro che gli ETF BTC avranno successo in futuro. Commentando su X, <a href="https://twitter.com/morningsmaria/status/1747979054874067159?s=46&amp;t=3iAFD_WHRWDFSLixlrJyWg" rel="nofollow noopener noreferrer" target="_blank">ha detto</a>, “È davvero molto importante, in gran parte è un ulteriore valido da istituzioni e, in questo caso, un ente governativo.” Il lancio di questi ETF criptovalutari permetterà alle grandi istituzioni di investire in bitcoin.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3728/what-does-bitcoin-etf-introduction-mean-for-investors" target="_blank">Cosa significa l’introduzione dell’ETF Bitcoin per gli investitori</a></p>
<h2 id="h2-Lindustria20delle20criptovalute20si20impegna20per20la20conformit20normativa20Garlinghouse734923"><a name="L’industria delle criptovalute si impegna per la conformità normativa: Garlinghouse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’industria delle criptovalute si impegna per la conformità normativa: Garlinghouse</h2><p>Oltre alla sua inesauribile <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> nei fondi ETF Bitcoin spot, Garlinghouse ha sottolineato che l’industria crittografica è disponibile a conformarsi alle normative crittografiche, indipendentemente dal luogo in cui sono emanate e applicate.</p>
<p>Ha commentato diversi paesi, tra cui Giappone, Svizzera e Regno Unito, per aver creato normative chiare sulle criptovalute che stabiliscono come gli investitori e le aziende cripto dovrebbero comportarsi.<br><img src="https://gimg2.gateimg.com/image/article/1706670242At299zNsy9.jpg" alt=""><br>Fonte: X.com</p>
<p>Indipendentemente dalla sua ottimismo nei confronti del prosperare dei bitcoin ETF negli Stati Uniti e nel resto del mondo, Garlinghouse ha criticato i regolatori governativi degli Stati Uniti per il modo in cui hanno gestito il processo di bitcoin ETF.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/a-comprehensive-analysis-of-key-information-on-btc-spot-etfs/1576" target="_blank">Un’analisi completa delle informazioni chiave sull’ETF Bitcoin BTC Spot</a></p>
<p>Questo perché Garlinghouse ritiene che i regolatori dovrebbero allineare le regole sulle criptovalute e altre politiche nazionali agli interessi pubblici. Ora, la sua critica è che i regolatori governativi degli Stati Uniti non stanno allineando le leggi sulle criptovalute con gli interessi del pubblico e con la tendenza globale emergente.</p>
<p>La sua prospettiva è che, a causa della natura decentralizzata degli asset digitali come le criptovalute, sia meglio che i paesi allineino le proprie normative sulle criptovalute per creare un sistema legale sinergico ed efficace che favorisca l’innovazione e protegga gli investitori. I commenti di Garlinghouse seguono il <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">prolungata SEC contro il ritardo dell’approvazione dell’ETF bitcoin spot</a>.</p>
<h2 id="h2-Cos20un20Spot20Bitcoin20ETF177975"><a name="Cos’è un Spot Bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un Spot Bitcoin ETF?</h2><p>Abbiamo discusso dell’ottimismo di Garlinghouse nei confronti degli ETF di bitcoin spot. Inoltre, abbiamo visto come gli ETF di bitcoin abbiano superato gli ETF di argento in termini di valore di mercato totale. Ora, approfondiamo brevemente cosa sono gli ETF di bitcoin?</p>
<p>Un ETF bitcoin spot è un fondo negoziato in borsa che segue il valore del bitcoin. Ciò significa che se non c’è un mercato <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">La manipolazione del prezzo del bitcoin dovrebbe correlarsi con il valore delle azioni che costituiscono un ETF di bitcoin</a>.</p>
<p>Un ETF bitcoin spot consente agli investitori di ottenere esposizione a bitcoin senza doverlo detenere. Tuttavia, gli ETF bitcoin spot vengono negoziati solo su borse tradizionali, non su borse cripto. Vale anche la pena notare che gli ETF BTC spot sono asset di investimento regolamentati, motivo per cui attraggono molti investitori.</p>
<h2 id="h2-Come20influenzano20gli20ETF20su20BTC20il20mercato20delle20criptovalute383587"><a name="Come influenzano gli ETF su BTC il mercato delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come influenzano gli ETF su BTC il mercato delle criptovalute?</h2><p>Gli ETF di spot bitcoin consentiranno a molti investitori tradizionali, comprese grandi istituzioni, di investire nell’asset crittografico. Il motivo è che gli ETF sono offerti su borse valori tradizionali dove molti investitori possiedono altri asset come azioni. Ad esempio, aziende come BlackRock e Fidelity, nomi noti nel settore, offrono ETF di spot bitcoin.</p>
<p>In secondo luogo, l’approvazione delle domande di ETF BTC contribuirà a incrementare la liquidità nel mercato del bitcoin. Tale aumento della liquidità faciliterà il trading efficiente sia per piccoli che grandi investitori.</p>
<p>Allo stesso modo, l’aumento della liquidità e del volume di trading può anche portare a una scoperta efficiente del prezzo che aiuta a stabilizzare la volatilità dell’asset crypto. Di conseguenza, porterà ad un mercato bitcoin stabile che attirerà più investitori.</p>
<p>Il momento rialzista che gli ETF di bitcoin possono sostenere potrebbe facilitare la crescita del settore delle criptovalute. In effetti, l’ottimismo che attualmente esiste nel mercato del bitcoin potrebbe svelare l’investimento in BTC e stimolare la crescita dell’industria. In tutto ciò, gli ETF di bitcoin spot hanno legittimato bitcoin agli occhi dei pessimisti di lunga data.</p>
<p>A lungo termine, gli ETF di bitcoin spot potrebbero indirettamente portare a un aumento sostenuto del prezzo del BTC. Ciò è perché il lancio degli ETF crittografici porterà a una maggiore adozione del bitcoin poiché una vasta sezione della società investe in esso. Alcune imprese avranno fiducia nel accettarlo come mezzo di pagamento per beni e servizi. È l’aumento della domanda di BTC che porterà al suo aumento di prezzo.</p>
<p>Inoltre, il lancio degli ETF BTC spot aumenterà la conoscenza pubblica di bitcoin e altre criptovalute attraverso i media e i forum di investimento, tra gli altri. Ciò potrebbe contribuire ad aumentare la sua adozione.</p>
<p>L’approvazione degli ETF di bitcoin potrebbe migliorare la chiarezza normativa nel settore. Ad esempio, la SEC degli Stati Uniti ha designato l’ETF di bitcoin spot come un ETF di materie prime. Ciò ha effettivamente confermato che il bitcoin è una merce piuttosto che un titolo. Allo stesso modo, se la SEC approva un ETF spot di ETH che potrebbe, altrettanto, legalmente avallare l’ETH come una merce.</p>
<h2 id="h2-Come20correla20il20valore20degli20ETF20di20Bitcoin20con20il20prezzo20del20BTC642773"><a name="Come correla il valore degli ETF di Bitcoin con il prezzo del BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come correla il valore degli ETF di Bitcoin con il prezzo del BTC?</h2><p>Gli emittenti di ETF su bitcoin hanno un sistema per garantire che il prezzo del bitcoin correli con il valore degli ETF. In particolare, il valore delle azioni ETF emesse da un’azienda dovrebbe corrispondere al numero di bitcoin che detiene.</p>
<p>Per allineare i valori delle azioni al numero di monete che possiede e riflettere sul valore di mercato prente del bitcoin, l’emittente venderà o comprerà costantemente l’attivo. Alcuni partecipanti autorizzati (AP), che sono grandi istituzioni finanziarie, facilitano il processo di creazione e rimborso. Inoltre, alcuni market maker si assicurano che ci sia equilibrio nel mercato degli ETF attraverso l’acquisto e la vendita delle azioni degli ETF.</p>
<h2 id="h2-Perch20la20SEC20era20contraria20agli20ETF20Bitcoin20spot917681"><a name="Perché la SEC era contraria agli ETF Bitcoin spot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché la SEC era contraria agli ETF Bitcoin spot?</h2><p>Per molto tempo, la SEC ha mostrato riserve riguardo all’approvazione degli ETF di bitcoin spot. Temeva la manipolazione di mercato che potrebbe esporre gli investitori a rischi finanziari.</p>
<p>Anche i regolatori del governo degli Stati Uniti erano preoccupati per la natura nascente del mercato delle criptovalute. Pertanto, la SEC voleva proteggere gli investitori e allo stesso tempo favorire l’innovazione. Inoltre, il fatto che il mercato delle criptovalute non fosse ancora maturo potrebbe aver influenzato il comportamento della SEC.</p>
<p>La concentrazione della proprietà di bitcoin nelle mani di pochi investitori (squali e balene) e l’arbitraggio tra i prezzi di bitcoin e gli ETF sono modi in cui potrebbe verificarsi la manipolazione di mercato.</p>
<h2 id="h2-Conclusione654528"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il valore di mercato degli ETF di bitcoin spot ha superato quello degli ETF dell’argento, creando ottimismo nel mercato delle criptovalute. Inoltre, il lancio degli ETF ha contribuito a svelare il bitcoin, il che potrebbe attrarre molti investitori nel settore. Ora, ciò che è importante per gli emittenti di BTC, i market maker, i partecipanti autorizzati (AP) e le borse è garantire che non ci sia manipolazione di mercato.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore 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. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>