R2xpIEVURiBCaXRjb2luIFNwb3QgcG9zc29ubyBkaXZlbnRhcmUgY2F0YWxpenphdG9yaSBkaSBtZXJjYXRvIHNlIGFwcHJvdmF0aT8=

2023-08-17, 02:11

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR169613"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Dato l’incremento generale del mercato delle criptovalute nel primo trimestre di quest’anno e l’attenzione del mercato, è rimasto invariato con continui fluttuazioni e adeguamenti dal secondo trimestre;</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è stato in un trend discendente negli ultimi due mesi, causando una grande quantità di Altcoin a diminuire di più del 10%;</p>
<p>Il tasso di cambio di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, che è sempre stata forte, ha raggiunto nuovi minimi uno dopo l’altro rispetto a Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/16922380996801692237998_.pic.jpg" alt=""><br>Grafico di tendenza giornaliera <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Gate.io - fonte: Gate.io</p>
<p>Dalla stagione di All Season nel primo trimestre alla stagione di Bitcoin nel secondo trimestre, c’è una crescente carenza di fondi sul mercato e la sostenibilità dei punti caldi del mercato è debole. Il mercato noioso e monotono spesso richiede eventi significativi per fare una svolta. Attualmente, i catalizzatori importanti che il mercato sta generalmente aspettando sono:</p>
<h2 id="h2-Quando20la20Federal20Reserve20ridurr20i20tassi20di20interesse838043"><a name="Quando la Federal Reserve ridurrà i tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando la Federal Reserve ridurrà i tassi di interesse</h2><p>Sebbene ci siano ancora alcuni disaccordi su se la Federal Reserve continuerà ad aumentare i tassi di interesse a settembre, l’opinione comune è che la Federal Reserve inizierà a tagliare i tassi di interesse già nel secondo trimestre dell’anno prossimo, che si combinerà con la riduzione a metà di Bitcoin nello stesso periodo, rendendolo un chiaro segnale di fattori interni ed esterni favorevoli. Nel breve termine, puoi prestare attenzione ai verbali monetari della Federal Reserve alle 2 del mattino del 17 agosto. Tuttavia, sulla base delle reazioni passate dei prezzi delle valute alle politiche della Federal Reserve, questo impatto marginale si sta indebolendo.</p>
<h2 id="h2-Quando20prosperer20lecosistema20Bitcoin478768"><a name="Quando prospererà l’ecosistema Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando prospererà l’ecosistema Bitcoin?</h2><p>Gran parte della prosperità del mercato delle criptovalute si è verificata durante l’estate, e BRC20 Summer ha introdotto nuovi concetti di Ordinali e Iscrizioni sul mercato. Le attività attive sulla catena hanno aumentato il reddito dei minatori, ma l’aumento dei costi delle transazioni ha anche ridotto l’accessibilità del Bitcoin, suscitando intense discussioni nella comunità. Purtroppo, non abbiamo visto una risposta positiva dalla popolarità di BRC20 Summer al prezzo del Bitcoin in quel giorno, e la prosperità dell’ecosistema Bitcoin richiede anche ulteriori miglioramenti infrastrutturali.</p>
<h2 id="h2-Quando20verr20approvato20lo20Spot20Bitcoin20ETF929154"><a name="Quando verrà approvato lo Spot Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando verrà approvato lo Spot Bitcoin ETF</h2><p>Gli ETF Bitcoin spot attireranno un gran numero di investitori istituzionali over-the-counter che non sono ancora entrati nel precedente mercato rialzista e potrebbero diventare il più grande catalizzatore per questo mercato rialzista. Attualmente, il mercato delle criptovalute sta vivendo una nuova situazione regolamentare in cui l’Occidente non è favorevole e l’Oriente è favorevole. “Diventare mainstream” significa che le criptovalute devono essere in grado di superare esperimenti regolamentari.</p>
<p>Il Canada, il Brasile e il Regno Unito hanno tutti lanciato ETF Bitcoin spot. Tuttavia, sulla base del maggiore impatto del dollaro statunitense (stablecoin) sul mercato del Bitcoin, l’atteggiamento di approvazione dei regolatori statunitensi, che attualmente dispongono di una grande quantità di denaro caldo in dollari statunitensi, verso gli ETF Bitcoin spot è diventato il punto più preoccupante.</p>
<p>La SEC degli Stati Uniti ha condotto una lunga revisione degli ETF Bitcoin spot e nonostante numerosi ritardi e respingimenti, una costante serie di istituzioni ha presentato domande per il prodotto. Attualmente, le società di investimento in attesa di decisioni ufficiali includono ARK Invest e 21Shares, Bitwise, BlackRock, VanEck, WisdomTree, Invesco e Galaxy Digital, Fidelity e Valkyrie. Queste società gestiscono complessivamente oltre $15 trilioni di asset globali.</p>
<p>Nonostante sia stata ritirata diverse volte, la SEC ha finalmente compiuto un passo significativo avanti. La SEC ha aperto un periodo di revisione di 21 giorni per l’ETF Bitcoin ARK 21Shares l’11 agosto, sollevando anche preoccupazioni sul protocollo di condivisione della sorveglianza di Coinbase, richiedendo ai commentatori di verificare se la partecipazione di Coinbase alla sorveglianza dell’ETF aiuti effettivamente a individuare, investigare e prevenire frodi e manipolazioni dei prezzi del Bitcoin.</p>
<p>Dal punto di vista temporale, la SEC deve rispondere al Bitwise Bitcoin ETP Trust entro il 1 settembre, mentre le decisioni sulle richieste di BlackRock, VanEck, WisdomTree e Invesco saranno prese un giorno dopo, con altre richieste che seguiranno da vicino.</p>
<p>Ma la SEC potrebbe continuare a ritardare, il che potrebbe essere correlato alle preoccupazioni riguardanti frodi di mercato e manipolazioni in cui il prodotto potrebbe essere coinvolto, nonché alla causa di Grayscale contro la SEC per aver rifiutato di convertire GBTC in un ETF Bitcoin spot. La decisione su questo caso sarà presa entro la fine di quest’anno.</p>
<p>In realtà, guardando indietro alla storia, che si tratti del lancio di ETF benchmark dell’oro o del lancio del Bitcoin Trust (GBTC), questi prodotti ETF hanno portato notevolmente l’intervento di fondi massicci e sono diventati importanti motori della prosperità di mercato.<br><img src="https://gimg2.gateimg.com/image/article/16922381936811692238028_.pic.jpg" alt=""><br>Cronologia del rilascio del fondo negoziato in borsa dell’oro (ETF) e tendenza dei prezzi dell’oro-Fonte: piattaforma di criptovalute</p>
<p><img src="https://gimg2.gateimg.com/image/article/16922382276821692238041_.pic.jpg" alt=""><br>Il mercato rialzista del Bitcoin nel 2020 accompagnato dalla crescita delle posizioni di Grayscale Bitcoin Trust - Fonte: Coinglass</p>
<h2 id="h2-Conclusione530430"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>A dieci anni dall’approvazione del primo Bitcoin Trust (GBTC) e dalla presentazione della dichiarazione di registrazione per gli ETF Bitcoin in contanti, l’approvazione degli ETF Bitcoin in contanti ha finalmente raggiunto un momento critico. Gli investitori sono ancora entusiasti e le autorità di regolamentazione stanno cautamente cercando misure di conformità.</p>
<p>L’interrogatorio finirà alla fine e abbiamo motivo di aspettarci che il canale di finanziamento tra criptovalute e mondo reale si aprirà presto. Grazie al suo basso investimento iniziale, bassi costi di negoziazione, buona liquidità e processo di trading semplice, l’approvazione degli ETF Bitcoin spot potrebbe porre fine alla debolezza attuale del mercato e promuovere ulteriormente il recupero e la prosperità del mercato delle criptovalute.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Peter G.</strong>, Ricercatore di Gate.io<br><div>Translator: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>