Tm90aXppZSBxdW90aWRpYW5lIHwgR2xpIEVURiBCaXRjb2luIGUgbGEgZnJlbmVzaWEgTkZUIGRvbWluYW5vIG1lbnRyZSBnbGkgaW52ZXN0aXRvcmkgYWNxdWlzdGFubyBmaWR1Y2lhIG5laSBkYXRpIGVjb25vbWljaSBkZWdsaSBTdGF0aSBVbml0aQ==

2023-06-28, 01:07

<p><img src="https://gimg2.gateimg.com/image/article/16879144280628.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Registrazione20di20Fidelity20ETF20a20leva20Successo20delle20NFT20e20Polemiche20sullApp20Store300947"><a name="Crypto Daily Digest: Registrazione di Fidelity, ETF a leva, Successo delle NFT e Polemiche sull’App Store" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Registrazione di Fidelity, ETF a leva, Successo delle NFT e Polemiche sull’App Store</h2><p>Fidelity Investments, una delle principali società di gestione patrimoniale, si sta preparando a presentare una posizione <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fondo negoziato in borsa (ETF). Questa notizia ha causato un momento di impennata nel prezzo di Bitcoin, con un aumento del prezzo da $30.260 a $31.000. Tuttavia, i guadagni sono stati di breve durata poiché la criptovaluta è rapidamente tornata a $30.500. Fidelity aveva precedentemente cercato di lanciare un ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot nel 2021, ma la domanda è stata respinta dalla Securities and Exchange Commission (SEC) degli Stati Uniti nel 2022.</p>
<p>La possibile presentazione da parte di Fidelity arriva subito dopo che l’unità iShares di BlackRock ha presentato una domanda per il proprio spot Bitcoin ETF, generando ulteriore interesse nel mercato delle criptovalute. L’approvazione di un spot Bitcoin ETF potrebbe avere un impatto significativo sul mercato, potenzialmente aumentando l’adozione di Bitcoin e fornendo ulteriori opportunità agli investitori di accedere all’asset digitale.</p>
<p>In altre notizie sulle criptovalute, il fondo negoziato in borsa Volatility Shares 2x Bitcoin Strategy (BITX) ha recentemente iniziato a essere scambiato negli Stati Uniti. BITX è il primo ETF cripto con leva finanziaria nel paese e ha registrato un volume di scambi di circa $4,2 milioni dal suo lancio. Nei primi 15 minuti di scambi, sono state negoziate azioni per un valore di circa $500.000. Il prezzo attuale delle azioni di BITX è di circa $15,48, riflettendo un aumento del 2% dall’inizio della sessione di trading.</p>
<p>Il lancio di BITX è significativo poiché segna l’ingresso degli ETF criptovalutari con leva nel mercato statunitense. Mentre esistono già prodotti ETF basati su futures, la SEC è stata più cauta nell’approvare gli ETF spot. Il lancio di BITO di ProShares, il primo ETF supportato dai futures di Bitcoin, nel 2021 ha raccolto un volume di scambi e attività di trading sostanziali.</p>
<p>Nel mondo dei token non fungibili (NFT), Azuki, un marchio NFT di spicco, ha realizzato <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> con il rilascio della sua ultima espansione chiamata “Azuki Elementals”. Questa collezione, che presenta 20.000 NFT basati sugli elementi della terra, del fuoco, del fulmine e dell’acqua, ha creato una frenesia sul mercato, generando 38 milioni di dollari in soli 15 minuti. Alcuni degli NFT sono stati distribuiti gratuitamente ai possessori, mentre quelli restanti sono stati resi disponibili per l’acquisto. L’alta domanda ha portato alla rapida esaurimento della collezione, eliminando la necessità di una vendita pubblica.</p>
<p>Tuttavia, il lancio degli Azuki Elementals non è stato privo di sfide. Molti acquirenti hanno espresso frustrazione a causa di problemi tecnici e della breve finestra di coniazione, rendendo difficile per alcuni acquisire gli NFT. Azuki ha riconosciuto i problemi e ammesso di aver sottovalutato il tempo necessario per la prevendita.</p>
<p>Rivolgendoci alle conseguenze di un fondo di copertura crittografico fallito, i liquidatori di Three Arrows Capital stanno cercando di recuperare 1,3 miliardi di dollari dai co-fondatori del fondo, Su Zhu e Kyle Davies. I liquidatori sostengono che Zhu e Davies abbiano causato al fondo di copertura l’assunzione di una leva significativa, con conseguenti perdite sugli investimenti come i token Luna. Affermano che l’azienda fosse già insolvente, spingendo ad agire in tribunale nelle Isole Vergini britanniche per recuperare queste perdite per i creditori del fondo.</p>
<p>Infine, l’ex CEO di Twitter Jack Dorsey, che ora guida la società di servizi finanziari Block incentrata su Bitcoin, ha pubblicamente messo in dubbio il CEO di Apple Tim Cook sulla mancanza di supporto a Bitcoin su Apple Pay. Questo è avvenuto dopo che Apple ha minacciato di rimuovere dall’App Store l’app di social media amica di Bitcoin Damus per la violazione delle linee guida per gli acquisti in-app. L’interrogativo di Dorsey solleva preoccupazioni sulla potenza di Apple sulle applicazioni per i consumatori e sottolinea il desiderio di un sistema finanziario resistente alla censura. L’incorporazione di Bitcoin in Apple Pay potrebbe potenzialmente guidare una significativa adozione di criptovalute.</p>
<h2 id="h2-Bitcoin20BTC2030538200512020Outlook20neutro13016"><a name="Bitcoin (BTC) $30,538 (-0.51%) - Outlook neutro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $30,538 (-0.51%) - Outlook neutro</h2><p><img src="https://gimg2.gateimg.com/image/article/1687914313Untitled0628 1.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1687914394Untitled0628 2.png" alt=""></p>
<p><strong>Panoramica:</strong></p>
<ul>
<li><strong><em>Zona di supporto giornaliera più vicina: 30025 - 29475</em></strong></li><li><strong><em>Zona di resistenza giornaliera più vicina: 30690 - 31015</em></strong></li><li><strong><em>Livello chiave: 28420 (massimo settimanale tra il 21 e il 28 dicembre 2020)</em></strong></li></ul>
<p><strong>Zone di resistenza quotidiana</strong></p>
<ol>
<li>30690 - 31015</li><li>31530 - 32255</li><li>33100 - 33600</li></ol>
<p><strong>Zone di supporto quotidiane</strong></p>
<ol>
<li>30025 - 29475</li><li>29095 - 28420</li><li>27970 - 27265</li></ol>
<h2 id="h2-Macro20gli20investitori20trovano20fiducia20nei20solidi20dati20economici20degli20Stati20Uniti20i20giganti20tecnologici20guidano20limpennata20delle20azioni92532"><a name="Macro: gli investitori trovano fiducia nei solidi dati economici degli Stati Uniti; i giganti tecnologici guidano l’impennata delle azioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: gli investitori trovano fiducia nei solidi dati economici degli Stati Uniti; i giganti tecnologici guidano l’impennata delle azioni</h2><p>I future sull’equity asiatica hanno registrato un aumento seguendo il forte rally di Wall Street trainato dalla solida fiducia dei consumatori e dalle vendite di abitazioni statunitensi. Il rimbalzo è stato guidato dai megacap tecnologici, con il Nasdaq 100 e l’S&amp;P 500 che si sono ripresi dopo una breve caduta. Da notare che Tesla, Snowflake e Meta Platforms hanno registrato guadagni, anche se Alphabet ha deluso a causa delle preoccupazioni sul suo ritmo nell’intelligenza artificiale.</p>
<p>Il cambiamento positivo della fiducia dei consumatori, che indica un atteggiamento più ottimista verso prezzi azionari più alti, suggerisce una potenziale resilienza del mercato. Nonostante le speculazioni sulla politica restrittiva della Federal Reserve, i forti dati economici segnalano un rischio ridotto di recessione quest’anno. Tuttavia, l’aumento dei rendimenti dei titoli del Tesoro ha alimentato le aspettative di una ripresa dei rialzi dei tassi di interesse da parte della Fed.</p>
<p>Nel trading post-mercato, le azioni tecnologiche statunitensi hanno subito un ritiro dopo che un rapporto del Wall Street Journal ha suggerito possibili restrizioni alle esportazioni di chip di intelligenza artificiale verso la Cina.</p>
<p>Gli investitori in Asia stanno monitorando da vicino i dati sugli utili industriali cinesi e i dati sull’inflazione australiana, che potrebbero influenzare le decisioni delle banche centrali in materia di tassi di interesse e misure di stimolo. Lo yuan offshore e il dollaro australiano sono rimasti stabili nelle prime contrattazioni asiatiche, mentre lo yen si è rafforzato rispetto al dollaro.</p>
<p>Più tardi oggi, l’attenzione del mercato si concentrerà su una discussione tra i capi della Federal Reserve, della Banca Centrale Europea, della Banca del Giappone e della Banca d’Inghilterra, che si terrà in Portogallo. Questa discussione è attesa per fornire spunti sulle prospettive delle banche centrali e sulle decisioni di politica.</p>
<p>Nel settore aziendale, American Equity Investment Life Holding ha ricevuto un’offerta significativa da Brookfield, Carnival Corp. ha ricevuto obiettivi aumentati dagli analisti e Delta Air Lines ha alzato le sue aspettative di guadagno. Al contrario, Walgreens Boots Alliance ha ridotto le sue previsioni di profitto e Lordstown Motors ha presentato istanza di fallimento.</p>
<p>I prezzi del petrolio hanno registrato un lieve aumento, mentre l’oro è rimasto relativamente stabile. Nel complesso, le positive performance del mercato azionario asiatico riflettono l’impatto di indicatori economici statunitensi solidi, ma le preoccupazioni riguardo a un potenziale stringimento della Fed e alle restrizioni sulle esportazioni di chip AI continuano a persistere nella mente degli investitori.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Peter L. </strong>, Ricercatore di Gate.io<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 il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>