Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGNyb2xsYSBkZWwgMTAlLCBXYWxsIFN0cmVldCByaXZlbGEgY2hlIE11c2sgaGEgcmlkb3R0byBsZSBzdWUgcGFydGVjaXBhemlvbmkgaW4gQlRDLCBsYSByaWR1emlvbmUgZGVsIGJpbGFuY2lvIGRlbGxhIEZlZCByYWdnaXVuZ2Vyw6AgMSB0cmlsaW9uZSBkaSBkb2xsYXJp

2023-08-18, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/16923375230818.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Wall20Street20rivela20che20Musk20ha20ridotto20le20sue20partecipazioni20in20Bitcoin20causando20una20caduta20del20mercato20del201020in20risposta806752"><a name="Crypto Daily Digest: Wall Street rivela che Musk ha ridotto le sue partecipazioni in Bitcoin, causando una caduta del mercato del 10% in risposta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Wall Street rivela che Musk ha ridotto le sue partecipazioni in Bitcoin, causando una caduta del mercato del 10% in risposta</h2><p>Oggi, verso le 21:30 (UTC), <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è improvvisamente crollato di oltre il 9%, raggiungendo un minimo di $25.409 e $24.715, con un calo del 9,41% nelle ultime 24 ore. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è sceso sotto i $1.600 nel breve termine, raggiungendo un minimo di $1.551,71. Attualmente è scambiato a $1.615,47, una diminuzione del 10,85% nelle ultime 24 ore.</p>
<p>Questo calo ha causato il valore di mercato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> a scendere al di sotto dei 500 miliardi di dollari per la prima volta dal 16 giugno e raggiungere il suo punto più basso dal 20 giugno.</p>
<p>Secondo i dati di CoinGlass, il forte calo ha comportato importi di compensazione superiori a $1 miliardo nelle ultime 24 ore, un aumento del 737,87% rispetto al giorno di negoziazione precedente. Ciò include $472 milioni di compensazione in Bitcoin e $302 milioni di compensazione in Ethereum, con la maggior parte delle posizioni interessate che sono lunghe.</p>
<p>La comunità crittografica ha attribuito alcuni dei cali a un rapporto del Wall Street Journal.</p>
<p>Il rapporto afferma che il bilancio di SpaceX ha registrato una svalutazione di $373 milioni in Bitcoin dal 2021 al 2022, e il momento esatto della vendita non è ancora chiaro. Musk ha menzionato in un discorso nel 2021 che SpaceX possiede Bitcoin, ma poiché l’azienda è una società privata, l’importo esatto non è stato divulgato.</p>
<p>Inoltre, Tesla, un’altra azienda di Musk, ha venduto oltre 30000 Bitcoin per 936 milioni di dollari nel secondo trimestre del 2022, rappresentando circa il 75% dei suoi iniziali 1,5 miliardi di Bitcoin.</p>
<p>Musk è sempre stato un appassionato a lungo termine delle criptovalute e nella sua introduzione ai social media X c’è un popolare <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> simbolo chiamato “Ð.” Come è ben noto, qualsiasi notizia legata a Musk avrà un impatto sul mercato.</p>
<p>Un’altra notizia che potrebbe stimolare la vendita è che lo sviluppatore immobiliare cinese Evergrande sta presentando domanda di protezione dal fallimento negli Stati Uniti, suscitando preoccupazioni tra gli investitori che i problemi nel mercato immobiliare cinese possano diffondersi ad altri settori dell’economia globale.</p>
<p>Nelle ultime settimane, i prezzi del Bitcoin sono stati in calo, cancellando circa la metà dell’aumento dopo che BlackRock ha presentato una richiesta di ETF Bitcoin il 15 giugno.</p>
<p>Secondo Bloomberg, uno dei fattori macro dietro il sell-off è il continuo aumento dei tassi di interesse globali, specialmente negli Stati Uniti, dove il tasso di interesse del bond del tesoro a 30 anni è salito al 4,42%, il livello più alto dal 2011. Il rendimento del bond del tesoro decennale era del 4,32, solo un punto base più basso del massimo di 15 anni. Questo non solo sopprime il prezzo delle criptovalute, ma colpisce anche gli asset rischiosi nei mercati tradizionali.</p>
<p>Shiliang Tang, Chief Investment Officer di LedgerPrime, una società di investimento in criptovalute, ha dichiarato che all’inizio di questa settimana le persone erano ottimiste riguardo l’introduzione della risoluzione per il Grayscale Bitcoin ETF questa settimana. Tuttavia, è stata infine approvata senza alcun risultato. Inoltre, i mercati tradizionali sono stati deboli per tutta la settimana, con l’indice S&amp;P 500 e le azioni tecnologiche in vendita, i tassi di interesse decennali raggiungendo livelli elevati, il dollaro americano in aumento e deboli dati di credito ed economici cinesi, tutti fattori che sono dannosi per gli asset rischiosi.</p>
<p>Secondo i dati di Kaiko, la volatilità a 90 giorni di Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è diminuita rispettivamente al 35% e al 37%, mentre la volatilità a 90 giorni del petrolio greggio ha raggiunto il 41%. La volatilità è il tasso a cui il prezzo di un determinato asset sale o scende entro un periodo di tempo specificato.</p>
<p>Da un punto di vista storico, il Bitcoin ha avuto una grande volatilità, cosa che non è stata il caso di recente, ma una brusca diminuzione del volume delle transazioni ha accompagnato questa insolita stabilità. I dati mostrano che il volume di scambi di Bitcoin ha raggiunto il suo livello più basso da novembre 2020 il mese scorso, con una volatilità di 30 giorni che si avvicina al minimo quinquennale.</p>
<p>Vale la pena notare che attualmente la volatilità del Bitcoin è inferiore a quella dell’indice S&amp;P 500, delle azioni tecnologiche, dell’oro, ecc.</p>
<h2 id="h2-I20principali20trend20dei20token20di20oggi583811"><a name="I principali trend dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I principali trend dei token di oggi</h2><h3 id="h3-BTC96645"><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/1692337565BTC.png" alt=""><br>Revisione della posizione corta trasmessa in diretta a $28,535 per BTC, con due livelli di obiettivo sotto $26,500 e $25,620. La posizione corta consigliata ha realizzato guadagni/perdite del 30.63%. Potrebbe esserci una continuazione di un movimento verso il basso a breve termine, stabilizzandosi intorno a $25,750 per avviare un rimbalzo minore. Si consiglia un ingresso e un’uscita veloci per cogliere i rimbalzi a breve termine.</p>
<h3 id="h3-ETH418864"><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/1692337580ETH.png" alt=""><br>Revisione della posizione breve della trasmissione in diretta piazzata a $1,815 per ETH, con due livelli obiettivo sotto $1,755 e $1,694. La posizione breve ha realizzato guadagni/perdite del 18.40%. Potrebbe esserci un’ulteriore continuazione di un movimento al ribasso a breve termine, stabilizzandosi intorno a $1,631.28 per avviare un lieve rimbalzo. Si consiglia un ingresso ed un’uscita rapidi per cogliere dei rimbalzi a breve termine.</p>
<h3 id="h3-SEI38729"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1692337597SEI.png" alt=""><br>L’obiettivo massimo di $0.2605 è stato raggiunto per SEI, con un potenziale ribassista continuo verso $0.1668 e $0.1535. Se il breve termine non ritorna a $0.1535, potrebbe esserci ulteriore movimento verso il basso. Le stime della sequenza di Fibonacci per i livelli di supporto inferiore includono $0.1433, $0.1362, $0.1290, $0.1202 e l’obiettivo inferiore di $0.1060.</p>
<h2 id="h2-Macro20La20riduzione20del20bilancio20della20Fed20raggiunger20120trilione20di20dollari20il20che20potrebbe20scatenare20unenorme20scossa20di20mercato479038"><a name="Macro: La riduzione del bilancio della Fed raggiungerà 1 trilione di dollari, il che potrebbe scatenare un’enorme scossa di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La riduzione del bilancio della Fed raggiungerà 1 trilione di dollari, il che potrebbe scatenare un’enorme scossa di mercato</h2><p>La Federal Reserve prevede di ridurre il suo massiccio bilancio a 1 trilione di dollari questo mese, segnando una pietra miliare importante nel tentativo di invertire anni di politica monetaria accomodante. Gli investitori hanno avvertito che ulteriori riduzioni del bilancio potrebbero influenzare i mercati finanziari.</p>
<p>Nei primi giorni della pandemia di COVID-19, la Federal Reserve ha acquistato trilioni di dollari di titoli di Stato e di titoli garantiti da ipoteche per contribuire a stabilizzare il sistema finanziario. Tuttavia, dall’ultima primavera, la Federal Reserve ha smesso di sostituire i suoi titoli quando sono scaduti.</p>
<p>Al 9 agosto, dopo aver raggiunto un picco di 8,55 trilioni di dollari a maggio dello scorso anno, il bilancio della Federal Reserve si è ridotto di 0,98 trilioni di dollari. L’analisi dei dati settimanali mostra che queste dimensioni dovrebbero superare 1 trilione di dollari entro la fine di questo mese.</p>
<p>La riduzione del bilancio della Federal Reserve, nota come stringimento quantitativo (QT), ha causato al mercato dei bond governativi di perdere uno dei suoi più grandi acquirenti, aumentando così l’offerta di debito che gli investitori privati devono assorbire.</p>
<p>Per la Federal Reserve, QT potrebbe essere un percorso instabile. La Federal Reserve è stata costretta a interrompere il suo tentativo nel 2019 dopo un brusco aumento dei costi di prestito causato da una riduzione su larga scala del bilancio e ha spaventato il mercato.</p>
<p>Finora, l’ultima fase di restrizioni è progredita senza intoppi, anche se la sua velocità è quasi il doppio rispetto al periodo 2018-2019. Gli investitori sostengono che questa resilienza riflette il fatto che il sistema finanziario globale è stato sommerso di liquidità a causa della pandemia. Tuttavia, lo sfondo di ulteriori restrizioni sta diventando sempre più difficile.</p>
<p>Jay Barry, co-direttore della strategia dei tassi di interesse americani di JPMorgan Chase, ha affermato che la seconda riduzione su scala trilionaria potrebbe avere un impatto maggiore. La prima riduzione su scala trilionaria è avvenuta in un contesto di rapido aumento dei tassi di interesse sui fondi federali, mentre la seconda riduzione su scala trilionaria è più importante perché si verificherà in un contesto di accelerata offerta di obbligazioni del Tesoro statunitense.</p>
<p>L’obiettivo della Federal Reserve è di ridurre il proprio bilancio di altri 1,5 trilioni di dollari entro metà 2025, mentre il governo degli Stati Uniti sta aumentando significativamente le dimensioni delle nuove emissioni di obbligazioni e la domanda degli investitori stranieri è anche in calo.</p>
<p>Ciò potrebbe aumentare i costi di prestito per governi e aziende, e causare perdite per molti investitori che hanno acquistato molte obbligazioni quest’anno. Questi investitori si aspettano che, con l’avvicinarsi della fine del ciclo di aumento dei tassi di interesse, i rendimenti dei titoli di Stato statunitensi diminuiranno.</p>
<p>Il senior economist dell’FMI Manmohan Singh ha affermato che un ulteriore 1 trilione di QT sarebbe equivalente a un aumento aggiuntivo di 15-25 punti base nel tasso dei fondi federali.</p>
<p>“Con la stabilizzazione dei tassi di interesse, l’impatto di un maggior QT potrebbe essere più facile da vedere”, ha detto.</p>
<p>Il Tesoro degli Stati Uniti ha aumentato la sua emissione di obbligazioni quest’anno per colmare il divario tra una diminuzione delle entrate fiscali e un aumento della spesa governativa. All’inizio di questo mese, il dipartimento ha annunciato che avrebbe ampliato la scala delle aste nel prossimo trimestre e ulteriormente ampliato nei prossimi trimestri. Megan Swiber, analista dei tassi di interesse presso la Banca d’America, ha stimato che la scala delle aste di alcuni bond potrebbe raggiungere il picco nel 2021 quando è avvenuto il picco di prestito della pandemia COVID-19.</p>
<p>Nel frattempo, ci si aspetta che la domanda dal Giappone, il più grande detentore straniero di obbligazioni del tesoro degli Stati Uniti, diminuisca. La Banca del Giappone ha allentato il suo controllo sul mercato dei bond governativi a luglio, spingendo i rendimenti dei bond giapponesi ai loro livelli più alti da quasi un decennio. I rendimenti dei bond più alti hanno portato alcuni investitori a prevedere che una grande quantità di fondi giapponesi <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> indietro, compreso un grande ammontare di fondi che fuoriescono dai titoli di stato degli Stati Uniti.</p>
<p>Tuttavia, i media stranieri hanno dichiarato che anche in questa situazione ci si aspetta che una riduzione del bilancio non porterà al disastro di liquidità che è avvenuto nel 2019. A differenza di quattro anni fa, c’è ancora una grande quantità di denaro nel sistema finanziario. Nonostante l’uso diminuito, uno strumento speciale progettato dalla Federal Reserve per assorbire eccessivo denaro assorbe ancora circa $1,8 trilioni per notte. I requisiti di riserva bancaria sono diminuiti quest’anno, ma sono ancora molto al di sopra del livello che la Federal Reserve ha iniziato a preoccuparsi.</p>
<p>Tuttavia, alcuni analisti ritengono che il rendimento del mercato dei titoli di stato del tesoro degli Stati Uniti possa aumentare significativamente, soprattutto per i titoli di stato a lungo termine.</p>
<p>“La riduzione passiva della scala della Fed dovrebbe portare ad una curva dei rendimenti più ripida”, ha detto Barry. “Anche se l’aumento dei tassi di interesse è stato praticamente completato, la riduzione della scala del bilancio potrebbe influenzare la curva dei rendimenti per il resto di quest’anno e il prossimo anno.”</p>
<p>Poiché il rendimento dei titoli di stato del tesoro statunitense supporta la valutazione di varie classi di attività, una brusca crescita significa anche che il costo degli imprenditori aumenta e potrebbe compromettere la crescita del mercato azionario quest’anno.</p>
<p>Scott Skyrm, un trader di repo presso Curvature Securities, ha detto: ‘Tutto ciò ha un impatto su acquirenti, venditori e sul mercato. Quando uno di loro cambia, ci sarà spesso maggiore volatilità. Mi aspetto che ci sia più volatilità a settembre e ottobre, poiché ci saranno più nuove emissioni di obbligazioni’.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 di questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che Gate.io sia menzionato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>