RGFpbHkgTmV3cyB8IEwnYWNjb3VudCBUd2l0dGVyIHVmZmljaWFsZSBkZWxsYSBTRUMgaGEgZGlmZnVzbyBub3RpemllIGZhbHNlLCBCVEMgw6ggc2Nlc28gaXN0YW50YW5lYW1lbnRlIGRlbCAxMCUsIG9sdHJlICQ1ME0gdmVuZHV0aSBpbiAxIG9yYSwgQlRDIMOoIHN0YXRvIHNjb2xsZWdhdG8gZGFsbCdpbmRpY2UgTkFTREFR

2024-01-10, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/17048713561_8.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Falsi20ETF20annunciati20a20causa20del20furto20dellaccount20Twitter20ufficiale20della20SEC20oltre205020milioni20di20dollari20venduti266714"><a name="Riepilogo giornaliero delle criptovalute: Falsi ETF annunciati a causa del furto dell’account Twitter ufficiale della SEC, oltre 50 milioni di dollari venduti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: Falsi ETF annunciati a causa del furto dell’account Twitter ufficiale della SEC, oltre 50 milioni di dollari venduti</h2><p>Il 10 gennaio, a causa delle false notizie secondo cui l’account Twitter ufficiale della SEC era stato rubato e il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Dopo l’approvazione dell’ETF spot, il prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> oscilla bruscamente. Dopo essere salito quasi a 48.000 dollari, è rapidamente sceso sotto i 45.000 dollari, con una fluttuazione a breve termine di quasi il 10%. Attualmente è riportato temporaneamente a 45.800 dollari, con un calo del 2,7% nelle ultime 24 ore.</p>
<p>Secondo i dati di Coinglass, il mercato del Bitcoin ha venduto $56.2 milioni nell’ultima ora, con ordini multipli che rappresentano circa il 60% del totale. La posizione attuale dei futures del Bitcoin è di $19.74 miliardi, in calo del 2.41% nelle ultime 4 ore. Tra questi, il CME rimane la piattaforma di trading con il maggior volume di futures di Bitcoin, con un volume detenuto di $6.12 miliardi e una quota di mercato del 30.99%.</p>
<p>Il presidente della SEC Gary Gensler ha successivamente twittato che l’account Twitter ufficiale della SEC era stato hackerato e erano stati pubblicati tweet non autorizzati. La quotazione e la negoziazione di spot Bitcoin ETF non sono ancora state approvate. In precedenza, l’account Twitter ufficiale della SEC ha annunciato che i Bitcoin spot ETF erano stati approvati per la quotazione su tutte le borse nazionali registrate. Al momento, il tweet è stato cancellato.</p>
<p>Tuttavia, l’analista di Bloomberg Eric Balchunas ha dichiarato sulla sua piattaforma di social media che, sebbene ci siano indizi che indicano il furto della spinta ufficiale della SEC, è più incline a credere che la falsa notizia sull’approvazione degli ETF Bitcoin spot della SEC provenga da dentro la SEC, o che abbia preparato un tweet pianificato per i dipendenti della SEC ma abbia inserito la data sbagliata, perché il linguaggio del tweet è in linea con lo stile della SEC e non è solo uno scherzo.</p>
<p>Successivamente, alcuni internauti hanno chiesto qual era la password dell’account X della piattaforma SEC e potevano rispondere solo con la risposta sbagliata. A riguardo, Musk scherza, “LFG Doge To The Moon.”</p>
<p>La SEC degli Stati Uniti ha confermato di aver ricevuto le proposte di modifica alle regole per gli ETF Bitcoin spot da parte di diversi richiedenti, tra cui Invesco Galaxy, Valkyrie, Franklin, Ark 21Shares, Fidelity, VanEck, Hashdex, Wisdomtree, Bitwise, ecc.</p>
<p>Il 9 gennaio, Eric Balchunas, analista senior ETF presso Bloomberg, ha affermato che BlackRock aveva appena presentato nuovamente il loro emendamento S-1 sulla base dei commenti ricevuti all’ultimo minuto ieri. A prima vista, è difficile distinguere eventuali cambiamenti, ma ciò che è importante è che questo tempo di risposta senza precedenti di soli 24 ore tra la presentazione dei documenti, la ricezione dei commenti e la presentazione ci dice che tutte le parti interessate stanno spingendo urgentemente avanti con questo progetto.</p>
<p>Eric Balchunas ha anche dichiarato che ci si aspetta che la SEC annunci l’approvazione degli ETF Bitcoin spot mercoledì dalle 16:00 alle 17:00 Eastern Time (5:00 alle 6:00 del mattino ora di Pechino di giovedì) e li elenchi giovedì ora locale.</p>
<p>In risposta, Steven McClurg, co-fondatore e Chief Information Officer di Valkyrie Investments, ha dichiarato anche che ci si aspetta che il Bitcoin ETF spot riceva l’approvazione della SEC entro la fine della giornata lavorativa di mercoledì e inizi a fare trading giovedì mattina. Ha detto che se il trading inizia giovedì, ci si aspetta che da $200 milioni a $400 milioni di fondi degli investitori saranno <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nell’ETF di Valkyrie, e tutti i partecipanti potrebbero vedere flussi di denaro pari a $4-5 miliardi nelle prime settimane.</p>
<p>Tuttavia, la giornalista di Fox Eleanor Terrett, che è stata sempre dalla parte opposta, ha pubblicato sui social media affermando che i cinque membri della SEC potrebbero ritardare l’approvazione degli ETF Bitcoin spot. I membri del comitato includono Gensler (D), Crenshaw (D), Peirce (R), Lizárraga (D) e Uyeda (R).</p>
<p>Anche se non è stata programmata alcuna votazione formale del comitato per gli ETF, ogni membro del comitato ha chiaramente il diritto di esaminare e votare per l’intero comitato in conformità con il 17 CFR 201.431, anche se la questione è stata assegnata e approvata tramite autorizzazione. Questa clausola consente a un commissario della SEC di richiedere all’intero comitato di esaminare questioni autorizzate dal personale.</p>
<p>Il direttore delle politiche di Paradigm, Justin Slaughter, ha dichiarato in precedenza che la SEC (come la Commodity Futures Trading Commission degli Stati Uniti e la maggior parte dei comitati) può consentire ai membri del comitato di votare su determinate questioni senza una riunione formale. Questo è un processo chiamato “seriatim”.</p>
<p>Nelle ultime settimane, il mercato ha gradualmente formato un consenso che l’approvazione o meno del BTC ETF porterà ad un’aggiustamento a breve termine del 20-30%. Ma secondo l’analisi dei dati on-chain di EMC Labs, l’aggiustamento potrebbe essere stato completato nelle ultime 6 settimane, manifestandosi come una fluttuazione sostenuta nei prezzi del Bitcoin tra $41.000 e $45.000.</p>
<p>Questo risultato potrebbe avere tre importanti fattori trainanti. In primo luogo, molti investitori hanno completato le loro operazioni di riduzione della posizione nel mese scorso, con le mani lunghe che tengono monete per oltre 5 mesi che hanno sperimentato una vendita concentrata di circa 60.000 monete per la prima volta nell’ultimo anno. Attualmente, questo comportamento di vendita si è praticamente fermato; Le mani corte che tengono monete entro 5 mesi hanno venduto un netto di oltre 400.000 monete nell’ultimo anno, raggiungendo un giro d’affari completo durante diversi periodi di consolidamento durante la lenta crescita di Bitcoin. Attualmente, il margine di profitto a breve termine è inferiore al 20%, e la motivazione alla vendita è insufficiente; In secondo luogo, dopo il 1° gennaio, l’afflusso netto di stablecoin si è accelerato, aumentando di $2,1 miliardi a settimana, avvicinandosi ai dati del mese completo di dicembre e raggiungendo il 40% del quarto trimestre del 2023; In terzo luogo, Bitcoin continua a sperimentare deflussi netti dagli exchange centralizzati, ma il deflusso netto è a un livello basso negli ultimi sei mesi. Oppure potrebbe significare che l’aggiunta di stablecoin non ha completamente formato un acquisto di Bitcoin e diventerà un supporto al potere d’acquisto per aggiustamenti a breve termine.</p>
<p>In sintesi, il prezzo attuale di Bitcoin potrebbe essere stato regolato nel breve termine dopo l’approvazione dell’ETF. Anche se gli ETF continuano a ritardare l’approvazione, l’adeguamento di mercato potrebbe non essere così significativo come precedentemente previsto.</p>
<h2 id="h2-Macro20Bitcoin20si2020scollegato20dallindice20NASDAQ20Deutsche20Bank20prevede20che20gli20Stati20Uniti20entreranno20in20recessione20questanno772879"><a name="Macro: Bitcoin si è scollegato dall’indice NASDAQ, Deutsche Bank prevede che gli Stati Uniti entreranno in recessione quest’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bitcoin si è scollegato dall’indice NASDAQ, Deutsche Bank prevede che gli Stati Uniti entreranno in recessione quest’anno</h2><p>Martedì, l’indice del dollaro americano è leggermente aumentato e alla fine è stato chiuso in ribasso dello 0,217% a 102,51. Il rendimento del Tesoro USA è continuato a diminuire, con il rendimento del Tesoro decennale che si è ridotto durante la negoziazione, chiudendo al 4,018%, più lontano dal massimo di tre settimane; il rendimento del Tesoro USA a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è stato chiuso al 4,366%.</p>
<p>L’oro spot ha oscillato lateralmente vicino al livello di 2030, chiudendo infine in rialzo dello 0,11% a $2.030,34 per oncia. L’argento spot ha continuato a diminuire durante la sessione statunitense, scendendo sotto il livello di 23 e chiudendo in ribasso dello 0,57% a $22,97 per oncia.</p>
<p>Il rischio di sversamento dal conflitto israelo-palestinese e la continua interruzione dell’approvvigionamento in Libia continuano a guidare un rimbalzo internazionale del petrolio greggio. Il petrolio greggio WTI è salito dell’1,84% a 72,14 dollari al barile e la differenza di prezzo spot del petrolio greggio WTI si è spostata su un premio spot per la prima volta da novembre dello scorso anno. Il petrolio greggio Brent è salito dell’1,47% a 77,47 dollari al barile.</p>
<p>I tre principali indici azionari statunitensi hanno guadagni e perdite miste, con il Dow Jones Industrial Average che chiude in ribasso dello 0,42%, il Nasdaq che sale leggermente e l’indice S&amp;P 500 che scende dello 0,15%. È anche noto che Bitcoin (BTC) si è recentemente scollegato dall’indice NASDAQ (NDX), ponendo fine alla tendenza di movimento sincronizzato con l’indice tecnologico di Wall Street per la maggior parte degli ultimi quattro anni.</p>
<p>Secondo i dati seguiti da Fairlead Strategies, la correlazione di 40 giorni tra Bitcoin e NASDAQ è attualmente zero, indicando una mancanza di correlazione tra queste due classi di asset. Dall’inizio del 2020, la correlazione tra Bitcoin e NASDAQ è stata positivamente correlata, raggiungendo un picco del 0,8 durante il mercato del crypto bear nel 2022.</p>
<p>Il crollo della correlazione significa anche che Bitcoin può ora fungere da strumento di diversificazione per i portafogli di investimento. Fairlead Strategies si aspetta che Bitcoin rimanga inalterato da NASDAQ per un certo periodo di tempo.</p>
<p>Riguardo alle recenti discussioni accese della Federal Reserve riguardo a un atterraggio morbido dell’economia degli Stati Uniti, Deutsche Bank ha affermato in un rapporto lunedì che l’esperienza storica mostra che questa tendenza si verifica spesso prima di una recessione.</p>
<p>Il rapporto della banca ha evidenziato che un’inflazione più bassa, dati occupazionali solidi e segnali che la Federal Reserve si sposterà verso tagli dei tassi di interesse quest’anno hanno guidato questa affermazione, e ha sottolineato che gli articoli di news stanno sempre più menzionando un “atterraggio morbido”. Trend simili si sono verificati prima della recessione economica all’inizio degli anni ‘90, all’inizio del XXI secolo e nel 2008. E si ritiene che il rischio che gli Stati Uniti cadano in una recessione economica sia maggiore che nel 2022 o 2023.</p>
<p>Si prevede che gli Stati Uniti entreranno in recessione quest’anno, ma questa potrebbe essere lieve o non avere un impatto significativo sul mercato.</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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>