Tm90aXppZSBxdW90aWRpYW5lIHwgTCdhcHByb3ZhemlvbmUgZGVnbGkgRVRGIEJpdGNvaW4gU3BvdCBhZ2dpdW5nZXLDoCAxIHRyaWxpb25lIGRpIGRvbGxhcmkgYWxsYSBjYXBpdGFsaXp6YXppb25lIGRpIG1lcmNhdG8gZGVsbGUgY3JpcHRvdmFsdXRlLCBUZXNsYSBub24gaGEgdmVuZHV0byBCVEMgbmVsIFEz

2023-10-19, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/16976939081019.jpg" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Fidelity20presenta20lultima20versione20dellETF20Bitcoin20spot20Tesla20non20ha20venduto20Bitcoin20nel20terzo20trimestre595437"><a name="Riassunto giornaliero delle criptovalute: Fidelity presenta l’ultima versione dell’ETF Bitcoin spot; Tesla non ha venduto Bitcoin nel terzo trimestre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: Fidelity presenta l’ultima versione dell’ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot; Tesla non ha venduto Bitcoin nel terzo trimestre</h2><p>Un documento regolamentare pubblico mostra che Fidelity ha presentato una versione aggiornata del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> presentare il prospetto del fondo negoziato in borsa (ETF) alla SEC, che include dettagli sugli accordi di custodia, meccanismi correlati alla hard fork, fonti di valutazione e prezzo, conformità GAAP, divulgazione dei rischi legati all’incertezza regolamentare e alla natura del consumo energetico del mining.</p>
<p>CryptoQuant, una società di analisi dei dati, ha scritto in un recente rapporto che se i fondi negoziati in borsa (ETF) di Bitcoin spot vengono approvati, Bitcoin diventerà un’attività del valore di $900 miliardi e l’intero mercato cripto crescerà di $1 trilione.</p>
<p>CryptoQuant ha dichiarato che se gli emittenti che richiedono di elencare gli ETF Bitcoin investono l’1% dei loro asset gestiti (AUM) in questi ETF, circa $ 155 miliardi potrebbero entrare nel mercato Bitcoin. Questo rappresenta quasi un terzo della capitalizzazione di mercato attuale di Bitcoin. Se si verificherà questa situazione, si presume che il prezzo di Bitcoin aumenterà tra $50.000 e $73.000.</p>
<p>Secondo il modello di CryptoQuant, storicamente, nei precedenti mercati rialzisti, la crescita del valore di mercato di Bitcoin è stata di 3-5 volte il suo capitale realizzato. CryptoQuant ha aggiunto che ciò indica che per ogni $1 di nuovi fondi che entrano nel mercato Bitcoin, il valore di mercato potrebbe aumentare di $3-5.</p>
<p>La giornalista di Fox Eleanor Terrett ha pubblicato sulla piattaforma X che la SEC ha incluso le criptovalute come obiettivo chiave della sua revisione del 2024. Tuttavia, la maggior parte delle società di criptovalute non sono registrate presso la SEC e quindi non pagano le tasse di registrazione.</p>
<p>Terrett ha inoltre dichiarato: “Questo indica forse che il presidente della SEC Gary Gensler sta dando priorità all’elaborazione delle criptovalute utilizzando risorse istituzionali e fondi pagati dalle società registrate, su cui non è ancora autorizzato a regolare? Oppure la SEC si aspetta che più società di criptovalute si registrino presso l’istituzione nel 2024?” Secondo le ultime notizie, il presidente della SEC Gary Gensler ha dichiarato che la SEC sta ancora valutando proposte per gli ETF spot di Bitcoin.</p>
<p>Secondo CoinDesk, la Standard Chartered Bank prevede di ospitare BTC e ETH per clienti istituzionali a Dubai nel primo trimestre del 2024. In futuro, la Standard Chartered Bank prevede anche di creare una rete di regolamento delle criptovalute.</p>
<p>Secondo Bloomberg, Mike Novogratz, fondatore di Galaxy Digital, si aspetta che la SEC alla fine approvi nel corso di quest’anno gli exchange-traded funds per l’investimento diretto in Bitcoin. Si dice che la vittoria di Grayscale sia significativa e che notizie positive significative spingeranno il mercato verso l’alto.</p>
<p>Secondo DL News, dopo l’incidente di JPEX, l’atteggiamento dei residenti di Hong Kong nei confronti degli asset crittografici è peggiorato. Un sondaggio della School of Business Administration presso l’Università di Scienza e Tecnologia di Hong Kong mostra che il 41% dei 2200 intervistati di età superiore ai 18 anni attualmente non è disposto a detenere alcun asset crittografico. Questo risultato rappresenta un aumento significativo del 12% rispetto a un sondaggio simile condotto su 5700 persone tra aprile e maggio.</p>
<p>Sebbene l’84% dei rispondenti dichiari di aver sentito parlare di asset virtuali, solo il 27% possiede o attualmente possiede cripto-asset. Inoltre, il desiderio di possedere cripto-asset in futuro si è anche indebolito, con solo il 20% delle persone che esprimono interesse, una diminuzione del 5% rispetto al sondaggio precedente. Tra coloro disposti a investire in cripto-asset, l’80% prevede di detenere cripto-asset del valore di 50000 HKD o meno.</p>
<p>Secondo CoinGap, secondo l’ultimo rapporto finanziario del terzo trimestre di Tesla, l’azienda non ha venduto alcun Bitcoin durante quel trimestre, segnando il suo quinto trimestre consecutivo senza operazioni di acquisto o vendita. Al 30 settembre, Tesla detiene circa 9720 Bitcoin con un valore di mercato di circa $275,6 milioni. Tesla non ha menzionato Bitcoin nel suo rapporto finanziario del terzo trimestre, il che indica che l’azienda non ha convertito la valuta digitale in valuta fiat. Vendere proattivamente Bitcoin potrebbe influire sulla sua redditività e sul saldo in contanti, che verrà registrato nel rapporto finanziario.</p>
<p>Dal secondo trimestre dell’anno scorso, Tesla non ha comprato o venduto Bitcoin. Nel secondo trimestre dell’anno scorso, Tesla ha venduto oltre 30.000 Bitcoin per 936 milioni di dollari, pari a circa il 75% delle sue partecipazioni in Bitcoin. L’azienda ha inizialmente acquistato Bitcoin per un valore di 1,5 miliardi di dollari all’inizio del 2021.</p>
<p>In termini di dati, la quota di mercato di Bitcoin è salita a un nuovo massimo da aprile 2021, segnalando temporaneamente il 49,31%; La quota di mercato di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è temporaneamente riportato al 16,72%; La quota di mercato di USDT è temporaneamente riportata al 7,43%. La capitalizzazione di mercato totale delle criptovalute su tutta la rete è di circa 1,1298 trilioni di dollari, con un aumento giornaliero dello 0,7%.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi643423"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC555287"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693943BTC.png" alt=""><br>Il punto più alto di questa settimana ha brevemente raggiunto i $30.000, ed è stato fatto un tentativo di mantenere il livello chiave di supporto a $28.125. La resistenza a breve termine si trova a $29.500. Il target di rottura critico a medio termine si trova a $33.085. Se questo livello non viene superato, potrebbe segnare la fine della tendenza di ripresa di quest’anno. Si consiglia di continuare a monitorare i livelli di resistenza.</p>
<h3 id="h3-ETH977344"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693960ETH.png" alt=""><br>Questa settimana ha visto un significativo rimbalzo del mercato, ma le tendenze di rimbalzo a breve termine e complessive rimangono deboli. L’obiettivo per il rimbalzo a $1.631 è stato raggiunto e continua a oscillare al di sotto del livello di $1.570. L’obiettivo al ribasso continua a essere intorno a $1.465, rendendo consigliabile una strategia ribassista a lungo termine.</p>
<h3 id="h3-STARL275885"><a name="STARL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STARL</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693982STARL.png" alt=""><br>Un precedente progetto di successo durante l’ultimo mercato rialzista, è passato da un prezzo base di $0,00523 a un picco di oltre $0,05562, più di dieci volte. Le aspettative a breve termine suggeriscono che il movimento verso l’alto potrebbe essere completo e si prevede un ritorno al livello di supporto di $0,00321.</p>
<h2 id="h2-Macro20I20prezzi20delloro20potrebbero20superare20i20200020dollari20la20Fed20si20orienta20verso20una20posizione20accomodante470668"><a name="Macro: I prezzi dell’oro potrebbero superare i 2000 dollari, la Fed si orienta verso una posizione accomodante" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I prezzi dell’oro potrebbero superare i 2000 dollari, la Fed si orienta verso una posizione accomodante</h2><p>Il dollaro statunitense, l’oro, i bond del tesoro statunitense e il petrolio greggio sono aumentati contemporaneamente di nuovo, simile alla situazione di venerdì. Ma questa volta, la differenza è che il calo del mercato azionario statunitense è molto maggiore rispetto a venerdì scorso. Se ci sarà un altro calo anomalo come ieri notte, il sentiment del mercato globale si deteriorerà rapidamente.</p>
<p>Attualmente, il prezzo dell’oro ha raggiunto $1,950, e la possibilità di superare i $2,000 nel breve termine è notevolmente aumentata. Se la situazione in Medio Oriente si calma, l’oro si ritirerà, ma attualmente il mercato si aspetta che la situazione si acutizzi ulteriormente. Ho la premonizione che l’impatto del mercato sul conflitto israelo-palestinese sarà molto più grande di quello della Russia e dell’Ucraina, poiché la situazione non ha ancora subito una sensibile deteriorazione, e il mercato ha già reagito in questo modo.</p>
<p>Il rendimento del Tesoro statunitense a 10 anni ha toccato il livello più alto dal 2007, chiudendo al 4,9042%. Questo è un ulteriore punto di rischio per il mercato, poiché il rapido aumento dei rendimenti obbligazionari ha indebolito l’entusiasmo del mercato per le azioni. Una volta che il rendimento del Tesoro USA a 10 anni raggiungerà il “5%”, potrebbe innescare un ciclo di vendite nel mercato azionario statunitense, che è un punto che tutti gli analisti di Wall Street stanno monitorando attentamente.</p>
<p>Il petrolio greggio è salito a causa della potenziale escalation del conflitto israelo-palestinese che potrebbe interrompere l’approvvigionamento. Dopo che l’Iran ha chiesto un embargo petrolifero su Israele, i prezzi del petrolio greggio WTI hanno brevemente raggiunto la soglia dei 90 dollari, chiudendo in rialzo dello 0,54% a 88,14 dollari al barile; il petrolio greggio Brent si è avvicinato ai 93 dollari nel trading, chiudendo in rialzo dello 0,47% a 91,3 dollari al barile.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso collettivamente al ribasso, con il Dow Jones Industrial Average in calo dello 0,98%, il Nasdaq in calo dell’1,62% e l’indice S&amp;P 500 in calo dell’1,34%. Nvidia ha chiuso in ribasso di quasi il 4% ed è sceso dell’8% questa settimana.</p>
<p>Aggiornamento della Federal Reserve: il governatore della Federal Reserve Waller ha lasciato intendere il suo sostegno per rimanere fermi; Brown Book: da settembre, l’attività economica è rimasta quasi invariata e i prezzi complessivi sono continuati a salire moderatamente; Williams: i tassi di interesse devono rimanere alti per un certo periodo di tempo per contenere l’inflazione; Huck ritiene che la Federal Reserve dovrebbe prolungare il periodo di pausa per gli aumenti dei tassi di interesse.</p>
<p>L’ultimo studio della Federal Reserve di New York mostra che a causa dei tassi di interesse più bassi e dei piani di estensione dei prestiti durante la pandemia, le fondamenta dei consumatori americani sono più stabili. Tuttavia, nel tempo, alcune famiglie potrebbero trovarsi di fronte a una maggiore pressione poiché i pagamenti dei prestiti agli studenti stanno riprendendo e i tassi di interesse stanno aumentando.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore Gate.io<br><div>Traduttore: 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>