RGFpbHkgTmV3cyB8IFNpIHByZXZlZGUgY2hlIGdsaSBFVEYgc2FyYW5ubyBhcHByb3ZhdGkgbWVyY29sZWTDrDsgTGUgcHJvcG9zdGUgZGkgcmVzdHJpemlvbmkgbm9uIHNvbm8gc3RhdGUgYXBwcm92YXRlOyBJbCBudW1lcm8gZGkgY29tbWVyY2lhbnRpIGZpc2ljaSBjaGUgYWNjZXR0YW5vIEJUQyDDqCB0cmlwbGljYXRv

2024-01-08, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17046976651_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Gli20ETF20sono20previsti20di20essere20approvati20gi20mercoled20di20questa20settimana20la20proposta20di20restrizione20delle20iscrizioni20non2020stata20approvata460091"><a name="Crypto Daily Digest: Gli ETF sono previsti di essere approvati già mercoledì di questa settimana, la proposta di restrizione delle iscrizioni non è stata approvata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Gli ETF sono previsti di essere approvati già mercoledì di questa settimana, la proposta di restrizione delle iscrizioni non è stata approvata</h2><p>Questa settimana segna una serie di scadenze importanti, che segnano l’apice di anni di sforzi per lanciare fondi negoziati in borsa (ETF) supportati da <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> negli Stati Uniti. Le istituzioni che sperano di emettere ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sono state obbligate a presentare le loro modifiche dell’ultimo minuto alle domande in sospeso entro mezzogiorno, ora di Washington, lunedì. La Securities and Exchange Commission degli Stati Uniti prevede di votare sui documenti 19b-4s presentati dagli scambi nei prossimi giorni.</p>
<p>Le autorità di regolamentazione possono o meno prendere provvedimenti sulla domanda dell’emittente (S-1) approssimativamente nello stesso momento. Se la SEC approva i due insiemi di approvazioni richieste, gli ETF possono iniziare a fare trading già dal giorno lavorativo successivo. Un rappresentante della Securities and Exchange Commission degli Stati Uniti ha rifiutato di commentare lo stato della domanda.</p>
<p>La giornalista di Fox Business Eleanor Terrett ha twittato che BlackRock si aspetta che il suo nuovo ETF Bitcoin spot riceva l’approvazione della SEC mercoledì di questa settimana, e si prevede che anche gli ETF di altre società di gestione patrimoniale ricevano l’approvazione. Inoltre, secondo fonti interne, BlackRock annuncerà licenziamenti entro circa tre giorni, che coinvolgeranno circa 600 dipendenti, pari al 3% della sua forza lavoro globale.</p>
<p>Il capo della ricerca sugli asset digitali di VanEck, Matthew Sigel, ha dichiarato in un evento Twitter Space di aver appreso da una fonte che oltre $2 miliardi di fondi sono in attesa di essere investiti negli ETF spot Bitcoin di BlackRock nella prima settimana dopo la loro quotazione, da parte di attuali detentori di Bitcoin.</p>
<p>Secondo Cointellegragh, le società di gestione patrimoniale che richiedono ETF spot Bitcoin presenteranno i documenti finali rivisti l’8 gennaio. Gli analisti si aspettano che la transazione inizi l’11 gennaio. Nella prossima fase, la SEC prenderà una decisione e i membri della SEC potrebbero votare. Ma secondo l’analista di Bloomberg Eric Balchunas, non c’erano disposizioni sull’agenda pubblica della SEC fino all’11 gennaio, ma la SEC potrebbe prendere decisioni utilizzando la sua politica di autorizzazione.</p>
<p>La società di gestione degli investimenti VanEck ha dichiarato sulla piattaforma X che, dopo l’approvazione dell’ETF Bitcoin spot, donerà il 5% del suo profitto ETF Bitcoin spot per sostenere l’organizzazione di sviluppo di base Bitcoin Brink per almeno 10 anni. Attualmente VanEck sta attendendo l’approvazione della SEC per lanciare il suo ETF Bitcoin spot.</p>
<p>L’analista di Bloomberg James Seyfhart ha twittato che gli ETF dell’oro hanno più potenziali problemi (impurità, contraffazioni, ecc.) rispetto agli ETF di Bitcoin. Nessuno costringe nessuno ad acquistare potenziali ETF di Bitcoin. Gli ETF non cambieranno Bitcoin stesso. Sono solo una scelta. Il vantaggio di un mercato libero è che possiamo lasciare che il mercato decida se gli ETF di Bitcoin hanno valore.</p>
<p>Il 7 gennaio, lo sviluppatore del client Bitcoin Core, Luke Dashjr, ha avviato una proposta intitolata “datacarriersize: Match more datacarrying #28408” per discutere se limitare le iscrizioni. Dopo la discussione tra diversi sviluppatori, la proposta non è stata approvata ed è attualmente chiusa.</p>
<p>Il 7 gennaio, Vitalik Buterin, co-fondatore di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, ha dato consigli finanziari sull’argomento di ‘se i portafogli di investimento dovrebbero essere diversificati’ sui social media: Diversificare i portafogli di investimento è buono; Risparmiare, cercare di risparmiare denaro fino a quando non ci sono abbastanza fondi per coprire anni di spese, la sicurezza finanziaria è libertà; Mantenere un portafoglio di investimento piatto per la maggior parte delle persone; Non utilizzare più di due volte la leva finanziaria, mai.</p>
<p>Il numero di commercianti fisici che accettano Bitcoin ha raggiunto un nuovo record. Il numero di commercianti fisici che accettano Bitcoin è quasi triplicato nel 2023, con oltre 6000 commercianti in tutto il mondo che accettano pagamenti in Bitcoin, molti dei quali si trovano in America Latina. Questo totale è quasi tre volte il numero di fornitori che accettavano Bitcoin alla fine del 2022, quando ce n’erano solo 2200. I commercianti di Bitcoin sono presenti in tutto il mondo, soprattutto concentrati in Europa, negli Stati Uniti e in America Latina, mentre l’accettazione in Asia orientale è relativamente bassa. A causa del divieto sulle criptovalute, la Cina ha quasi nessun commerciante che accetta Bitcoin.</p>
<p>In termini di sblocco dei dati dei token di questa settimana, secondo i dati di sblocco dei token, dal 8 gennaio al 14 gennaio, i token GLMR, APT e CYBER esperimenteranno uno sblocco unico, con un valore totale rilasciato di circa $236 milioni. Tra di essi:</p>
<p>L’11 gennaio alle 00:00 (UTC), <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> Il token GLMR sbloccherà 304 token (circa $ 1,2 milioni), corrispondenti al 0,38% dell’offerta circolante;</p>
<p>Il 12 gennaio alle 01:59 (UTC), <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> Il token APT sbloccherà 24,84 milioni (circa 225 milioni di dollari), corrispondenti all’8,05% dell’offerta circolante;</p>
<p>Il 14 gennaio alle 14:24 (UTC), il token CyberConnect CYBER sbloccherà 1,26 milioni (circa 9,03 milioni di dollari), pari all’8,51% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20del20token20di20oggi458136"><a name="Tendenze principali del token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali del token di oggi</h2><h3 id="h3-BTC185726"><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/1704697705BTC.png" alt=""><br>La settimana scorsa, BTC è tornato a un supporto basso di $40.750 e poi è rimbalzato verso l’asse di tendenza. Stamattina è nuovamente sceso vicino al livello di $43.000. Ci si aspetta che la tendenza di questa settimana continui verso il basso. Si consiglia di non speculare sui movimenti a breve termine. Attenzione alle possibili opportunità di vendita al ribasso su una rottura al di sotto, con i livelli di supporto chiave a $40.280 e $38.400 per il medio termine.</p>
<h3 id="h3-ETH968905"><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/1704697720ETH.png" alt=""><br>Il grafico delle quattro ore mostra segni di una formazione al top. L’attenzione a breve termine è su se il supporto di $2.135 si tiene, che è una svolta critica a medio termine. Se violato, potrebbe ritestare i livelli di supporto a $2.037 e $1.974. Il trading a breve termine può essere considerato in caso di ritracciamento, mantenendo nel contempo una visione rialzista a lungo termine.</p>
<h3 id="h3-POWR671100"><a name="POWR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>POWR</h3><p><img src="https://gimg2.gateimg.com/image/article/1704697732POWR.png" alt=""><br>Sono evidenti chiari segni di manipolazione di mercato nei recenti movimenti di POWR. Dopo aver raggiunto quasi $0,9425 da una base di $0,1245, i prezzi sono rapidamente scesi sotto $0,5195 entro 2 ore, ponendo un rischio di liquidazione per le posizioni long. Il supporto a breve termine si trova a $0,4278, offrendo un’opportunità di rimbalzo con una gestione del rischio attenta. A lungo termine, si consiglia di mantenere posizioni spot a causa dei potenziali rischi di liquidazione associati ai contratti.</p>
<h2 id="h2-Macro20La20prima20settimana20del20nuovo20anno2020volatile20la20Fed20potrebbe20non20escludere20la20possibilit20di20aumentare20nuovamente20i20tassi20di20interesse212181"><a name="Macro: La prima settimana del nuovo anno è volatile, la Fed potrebbe non escludere la possibilità di aumentare nuovamente i tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La prima settimana del nuovo anno è volatile, la Fed potrebbe non escludere la possibilità di aumentare nuovamente i tassi di interesse</h2><p>Nella prima settimana del nuovo anno, dopo il rimbalzo del rendimento del titolo del tesoro americano e il rafforzamento del dollaro americano, il sentimento di rischio è diminuito da uno stato estremamente rialzista. Il mercato azionario ha iniziato male, con i tre principali indici azionari americani che hanno interrotto le loro nove settimane consecutive di guadagni e il Nasdaq che ha registrato il suo più grande calo settimanale da settembre. L’oro ha registrato il suo primo calo settimanale in quattro settimane. A causa del continuo aggravarsi della situazione in Medio Oriente e della chiusura completa del più grande campo petrolifero della Libia, le preoccupazioni per le interruzioni dell’approvvigionamento petrolifero si sono intensificate sul mercato. Di conseguenza, i mercati petroliferi statunitensi e birmani hanno chiuso al rialzo nella prima settimana di quest’anno.</p>
<p>È un fenomeno tipico del mercato sperimentare fluttuazioni all’inizio del nuovo anno.</p>
<p>Tuttavia, il declassamento del rating di Apple due volte in una settimana ha suscitato preoccupazioni tra gli investitori che le sue azioni siano diventate ipercomprate dopo i recenti guadagni. Il forte rapporto sull’occupazione di venerdì e il declino inaspettato dei dati dei servizi ISM hanno reso l’outlook sui tassi di interesse ancora più confuso. Dato che le aspettative sui tassi di interesse accomodanti sono sempre state uno dei principali catalizzatori che guidano il rimbalzo del mercato entro la fine del 2023, gli investitori monitoreranno attentamente i prossimi dati sull’inflazione nella prossima settimana per determinare se le aspettative di mercato siano già avanzate. Anche l’evoluzione della situazione nel Mar Rosso continuerà a fare notizia.</p>
<p>D’altra parte, la non-farm payroll della settimana scorsa ha superato le aspettative del mercato ed è anche degna di nota.</p>
<p>Il tasso di disoccupazione negli Stati Uniti a dicembre era del 3,7% (valore precedente: 3,7%; aspettativa di mercato: 3,8%); Dopo il riallineamento trimestrale a dicembre, la popolazione occupata non agricola negli Stati Uniti era di 21,6 (valore precedente: 19,9; aspettativa di mercato: 17) - superiore alle aspettative di mercato; Aumento medio dell’orario lavorativo dello 0,4% (valore precedente: 0,4%; aspettativa di mercato: 0,3%) - superiore alle aspettative di mercato (crescita salariale accelerata).</p>
<p>Da qualsiasi prospettiva, questi dati hanno spinto il mercato a ridurre le scommesse sul taglio dei tassi d’interesse della Federal Reserve. Attualmente, Wall Street ha ridotto le sue aspettative per un taglio dei tassi a marzo, e alcune banche d’investimento hanno addirittura avvertito in anticipo che il primo taglio dei tassi sarà intorno a giugno. Tali aspettative di mercato sono destinate a colpire i trader, quindi dobbiamo fare un buon lavoro nell’anticipare il ritardo del taglio dei tassi della Federal Reserve.</p>
<p>Molti analisti considerano il mercato di gennaio come un barometro della tendenza annuale del mercato (l’indicatore utilizzato per misurare le future tendenze di mercato a gennaio ha un record affidabile), un noto proverbio di Wall Street che è stato dimostrato essere vero l’anno scorso.</p>
<p>L’anno scorso, l’indice del dollaro USA è sceso a gennaio, mentre il mercato azionario USA, l’oro e i titoli di stato USA sono aumentati a gennaio. Infine, il dollaro USA è sceso per tutto l’anno, e quest’ultimo è aumentato rapidamente, creando un anno inaspettato. E quest’anno, il mercato globale è iniziato con il peggiore record della storia, con i mercati globali dei bond e delle azioni che hanno perso oltre 3 trilioni di dollari in solo una settimana.</p>
<p>Il valore di mercato delle sette grandi azioni che hanno guidato l’andamento del mercato azionario statunitense nel 2023 è evaporato di oltre 400 miliardi di dollari, cancellando tutti i guadagni di dicembre. Per i restanti 20 giorni, dobbiamo vedere se il mercato può invertire la tendenza e riprendersi. Tuttavia, al momento ci sono ancora alcune difficoltà. Ciò significa che l’intero anno 2024 continuerà a seguire le orme di gennaio e dobbiamo continuare ad osservare. Per gli analisti che prestano attenzione alla tendenza di gennaio, si basa su statistiche di dati passati e non è certo se i dati di quest’anno possano continuare.</p>
<p>Il 7 gennaio, la Federal Reserve Logan ha avvertito che potrebbe essere necessario riprendere l’aumento dei tassi di politica a breve termine per evitare che il recente calo dei rendimenti dei titoli di stato a lungo termine riaccenda l’inflazione.</p>
<p>“Se non manteniamo condizioni finanziarie sufficientemente strette, rischiamo che l’inflazione riprenda e annulli i progressi compiuti”, ha detto Logan. “Le condizioni finanziarie restrittive hanno svolto un ruolo importante nell’allineare la domanda con l’offerta e nel mantenere aspettative di inflazione stabili”, ha sottolineato, osservando che i tassi di inflazione si avvicinano all’obiettivo della Federal Reserve del 2%, e nonostante il mercato del lavoro sia ancora stretto, si sta riequilibrando. Se non manteniamo condizioni finanziarie sufficientemente rigide, non possiamo aspettarci di mantenere la stabilità dei prezzi.</p>
<p>Il prezzo dei tagli ai tassi di interesse nel mercato è stato significativamente superiore a quello della Federal Reserve, e attualmente i futures sui tassi di interesse sembrano prevedere sei tagli dei tassi di interesse quest’anno. Rispetto alle indicazioni fornite dalla Federal Reserve nella riunione di dicembre, questa è chiaramente una visione più accomodante. Secondo il verbale della riunione del mese scorso, i tassi di interesse potrebbero aver raggiunto il loro picco, ma i responsabili politici non hanno ancora discusso quando iniziare a tagliare i tassi, e alcuni funzionari non escludono la possibilità di ulteriori aumenti dei tassi. Il grafico di dicembre della Federal Reserve mostra che ci saranno solo tre tagli dei tassi di interesse entro la fine del 2024.</p>
<p>Pertanto, ulteriori progressi nell’inflazione degli Stati Uniti saranno monitorati per sostenere l’argomento che le pressioni sui prezzi sono sotto controllo e fornire spazio ai responsabili delle politiche per riassestare le loro opinioni sui tagli ai tassi di interesse.</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 su questo articolo. Sarà consentito il ripostaggio dell'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>