Tm90aXppZSBxdW90aWRpYW5lIHwgZ2xpIFN0YXRpIFVuaXRpIGludHJvZHVycmFubm8gbGEgc3VhIHByaW1hIHZlcnNpb25lIGRlbCBzaXN0ZW1hIGRpIGNvbnRhYmlsaXTDoCBkZWxsZSBjcmlwdG92YWx1dGUsIEpQTW9yZ2FuIENoYXNlIHByZXZlZGUgY2hlIEVUSCBzdXBlcmVyw6AgQlRDIGwnYW5ubyBwcm9zc2ltbw==

2023-12-14, 04:01

<p><img src="https://gimg2.gateimg.com/image/article/17025350901_9.png" alt=""></p>
<h2 id="h2-Riepilogo20criptovalute20quotidiano20gli20Stati20Uniti20introdurranno20la20loro20prima20versione20del20sistema20di20contabilit20criptata20JPMorgan20Chase20prevede20che20Ethereum20superer20Bitcoin20lanno20prossimo125219"><a name="Riepilogo criptovalute quotidiano: gli Stati Uniti introdurranno la loro prima versione del sistema di contabilità criptata, JPMorgan Chase prevede che Ethereum supererà Bitcoin l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo criptovalute quotidiano: gli Stati Uniti introdurranno la loro prima versione del sistema di contabilità criptata, JPMorgan Chase prevede che <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> supererà <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> l’anno prossimo</h2><p>Mercoledì, il Financial Accounting Standards Board (FASB) ha rilasciato la prima serie di regole contabili per le criptovalute, richiedendo alle aziende di misurare le loro detenzioni di criptovalute al valore equo. Le nuove normative entreranno in vigore nel 2025, ma consentono l’adozione anticipata.</p>
<p>Questa modifica delle regole significa che aziende come MicroStrategy, Tesla e Block saranno in grado di registrare i massimi e minimi di valore dei loro titoli crittografici. Secondo le nuove normative, le aziende che detengono criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> o <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> dovrà registrare questi token al valore equo, che è l’ultimo valore di mercato. Le variazioni del valore equo saranno riconosciute direttamente nel reddito netto.</p>
<p>Secondo le nuove regole, le aziende devono registrare separatamente i loro asset criptati come voce nel bilancio. Devono inoltre rivelare una quantità significativa di possedere asset criptati e qualsiasi restrizione su questi asset nelle note a piè di pagina di ciascun periodo di rendicontazione. Ogni anno devono conciliare o rivelare le variazioni nei saldi iniziali e finali degli asset criptati per categoria.</p>
<p>In termini di regolamentazione, Rostin Behnam, presidente della Commodity Futures Trading Commission (CFTC) degli Stati Uniti, ha affermato che secondo la legge attuale, la maggior parte degli asset crittografici sono materie prime, e riconosce che le agenzie di regolamentazione sono coinvolte in una “guerra territoriale” su chi ha l’autorità di regolare l’industria crittografica.</p>
<p>Discutendo della complessità normativa affrontata dall’industria delle criptovalute, Behnam ha sottolineato la necessità di un’azione legislativa urgente e ha affermato che “i membri del Congresso stanno lavorando duramente per comprendere la situazione”. Behnam ha sottolineato che una delle sfide nella regolamentazione degli asset digitali è la “guerra territoriale” in corso tra le varie agenzie di regolamentazione del paese, in particolare la questione tra la Securities and Exchange Commission (SEC) degli Stati Uniti e la CFTC in merito a chi regolerà il settore. Questo conflitto è diventato un grosso ostacolo alla definizione di linee guida normative chiare per gli asset digitali e per l’industria delle criptovalute in generale.</p>
<p>Mentre il mercato si riprende, anche le banche d’investimento più famose sono uscite per conquistare traffico. Gli analisti di JPMorgan affermano che il mercato cripto nel complesso rimane ‘cauto’ nell’anno a venire, ma le performance di Ethereum nel 2024 potrebbero superare quelle di Bitcoin e altre criptovalute.</p>
<p>Gli analisti di JPMorgan guidati da Nikolaos Panigrtzoglou hanno scritto in un rapporto mercoledì: “Crediamo che Ethereum ristabilirà la propria posizione l’anno prossimo e riconquisterà quote di mercato nell’ecosistema crittografico.” Il principale catalizzatore è l’aggiornamento EIP-4844, previsto nel primo semestre del 2024. Questo aggiornamento potrebbe compiere un passo più grande verso il miglioramento delle attività della rete Ethereum, aiutando così Ethereum a performare bene.</p>
<p>Gli analisti di JPMorgan hanno ribadito che questo aggiornamento è particolarmente vantaggioso per le reti L2 come Arbitrum e <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, in quanto fornisce spazio dati temporaneo aggiuntivo per aumentare la capacità della rete e ridurre i costi delle transazioni per le reti Ethereum L2. Gli analisti di JPMorgan hanno anche dichiarato che i fattori considerati favorevoli per Bitcoin l’anno prossimo, tra cui l’approvazione possibile degli ETF spot e l’imminente dimezzamento, sono stati riflessi nel prezzo.</p>
<p>L’analista ha concluso: “dato che il rapporto attuale tra i prezzi del Bitcoin e i costi di produzione è di circa il doppio, ciò significa che il dimezzamento del Bitcoin nel 2024 è stato in gran parte riflesso nel prezzo”.</p>
<p>Matthew McDermott, responsabile globale degli asset digitali presso Goldman Sachs, ha detto che ci si aspetta che il volume di scambi di asset basati su blockchain aumenti in modo significativo nei prossimi uno o due anni. McDermott ha dichiarato che, poiché il mercato prevede che i regolatori statunitensi dei titoli approveranno presto le domande per gli ETF Bitcoin spot (fondi negoziati in borsa), Goldman Sachs ha riscontrato un aumento dell’interesse nel trading di derivati crittografici tra i clienti.</p>
<p>Bitcoin è salito di oltre il 50% questo trimestre, ma McDermott ha dichiarato che si concentra ancora sullo sviluppo di asset digitali al di là delle criptovalute, incluso l’emissione di token basati su blockchain che rappresentano asset tradizionali come obbligazioni. Ha affermato che c’è una “enorme domanda” di asset digitali e che c’è stato una “crescita significativa” negli ultimi 12 mesi; L’uso della blockchain può migliorare l’efficienza operativa e di regolamento, nonché “de-ridurre” i mercati finanziari; Se le negoziazioni di titoli vengono effettuate tramite la blockchain, la garanzia e la liquidità possono essere inviate tra le parti in modo più rapido e preciso.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi754386"><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-BTC486701"><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/1702535131BTC.png" alt=""><br>Dopo l’ascesa complessiva del mercato all’inizio di ieri, il grafico a quattro ore ha fatto un pullback al di sopra dell’asse centrale della tendenza al rialzo. Nel breve termine, ci si aspetta che continui la tendenza al rialzo con riprese rapide. La resistenza del grafico settimanale è a $45,345 e $47,990. Per le strategie a lungo termine, si consiglia di aspettare un secondo pullback per un approccio conservativo, con supporto a lungo termine a $30,888.</p>
<h3 id="h3-ETH499785"><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/1702535157ETH.png" alt=""><br>La scorsa settimana, l’obiettivo di prezzo di $2,381 per ETH è stato raggiunto, e il grafico giornaliero suggerisce una possibile formazione di un triangolo simmetrico ad alto livello. Si consiglia cautela per un significativo ritracciamento, mentre la raccomandazione a lungo termine è di mantenere il trend al rialzo. L’obiettivo di breakout è a $2,805, con target a lungo termine a $8,025 e $12,397.</p>
<h3 id="h3-GT437293"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/1702535350GT.png" alt=""><br>Il grafico settimanale mostra un mercato strutturato che si avvicina alla fine della seconda fase, entrando nel terzo ciclo di mercato rialzista. Discutendo del terzo ciclo di mercato rialzista, qual sarà l’obiettivo massimo di GT?</p>
<p>Nella seconda fase, GT ha raggiunto il primo obiettivo a $2.9321 (che corrisponde al 4.236 della sequenza di Fibonacci della prima fase) e il secondo obiettivo a $12.8770.</p>
<p>Il triangolo giallo rappresenta l’intervallo della seconda fase, con potenziali obiettivi per la terza fase a $28.2426, $39.1555 e $44.9951.</p>
<p>Se si forma un mercato toro sostenuto, i prezzi potrebbero continuare ad influenzare $110.3832 e $176.8363, a seconda dell’accumulo di fondi e delle opportunità nel prossimo ciclo di mercato toro.</p>
<h2 id="h2-Macro20La20Federal20Reserve20aumenta20la20posizione20accomodante20il20grafico20a20punti20della20Fed20suggerisce20un20taglio20dei20tassi20di20interesse20di207520punti20base20lanno20prossimo670684"><a name="Macro: La Federal Reserve aumenta la posizione accomodante, il grafico a punti della Fed suggerisce un taglio dei tassi di interesse di 75 punti base l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La Federal Reserve aumenta la posizione accomodante, il grafico a punti della Fed suggerisce un taglio dei tassi di interesse di 75 punti base l’anno prossimo</h2><p>La Federal Reserve ha annunciato che i tassi di interesse rimarranno invariati nell’intervallo dal 5,25% al 5,50%, in linea con le aspettative. Dall’inizio di quest’anno, la Federal Reserve ha aumentato i tassi di interesse di un totale di 100 punti base e li ha mantenuti ai loro livelli attuali da settembre.</p>
<p>A causa dell’ovvio atteggiamento accomodante della Federal Reserve, i rendimenti del Tesoro USA sono diminuiti su tutta la linea e il rendimento del Tesoro USA decennale ha evitato di poco il livello del 4%, chiudendo infine al 4,024%; Il rendimento del Tesoro USA biennale, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è sceso di oltre 30 punti base nella giornata e ha chiuso al 4,429%. L’indice del dollaro USA è crollato intraday, scendendo sotto il livello di 103 e chiudendo infine in ribasso dello 0,809% a 102,98.</p>
<p>Il prezzo dell’oro spot è salito bruscamente dopo che è stata annunciata la decisione sui tassi di interesse della Federal Reserve, raggiungendo 2020 dollari per oncia. È salito quasi di 50 dollari nel corso della giornata e alla fine ha chiuso in rialzo del 2,26% a 2024,26 dollari per oncia; L’argento spot è salito del 4,65% chiudendo a 23,81 dollari per oncia.</p>
<p>A causa di una diminuzione maggiore del previsto delle scorte di petrolio greggio negli Stati Uniti e delle preoccupazioni per la sicurezza dell’approvvigionamento di petrolio del Medio Oriente causate dall’attacco alle petroliere del Mar Rosso, il petrolio greggio internazionale è leggermente ripreso da un minimo di 5 mesi. Il petrolio greggio WTI ha chiuso in rialzo del 1,7% a $69,95 al barile; il petrolio greggio Brent è salito dell’1,81% a $74,81 al barile.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso in rialzo, con il Dow Jones Industrial Average in aumento del 1,4%, raggiungendo quota 37090 punti, stabilendo un nuovo massimo di chiusura. L’indice S&amp;P 500 ha chiuso in rialzo del 1,37%, e il Nasdaq è salito dell’1,38%.</p>
<p>La dichiarazione del FOMC della Federal Reserve mostra che il tasso di crescita dell’economia degli Stati Uniti si è rallentato rispetto al forte slancio di crescita nel terzo trimestre. La crescita dell’occupazione si è rallentata, ma rimane forte, e il tasso di disoccupazione rimane basso. L’inflazione negli Stati Uniti si è rallentata nell’ultimo anno, ma rimane alta, e il FOMC resta fermamente impegnato nel raggiungimento dell’obiettivo di ripristinare l’inflazione al 2%.</p>
<p>Il tasso di riduzione delle detenzioni in titoli del Tesoro statunitense e MBS rimarrà invariato. Il Dot Plot della Federal Reserve suggerisce un taglio dei tassi di interesse di 75 punti base l’anno prossimo, con un tasso di interesse mediano previsto dei fondi federali del 4,6% entro la fine del 2024. Il “Dot Plot” del comitato raffigura anche quattro tagli dei tassi nel 2025 e tre tagli dei tassi nel 2026, che porteranno il tasso dei fondi federali nell’intervallo del 2% al 2,25%. Ha dichiarato di essere pronta a stringere ulteriormente la politica monetaria in condizioni appropriate.</p>
<p>Il grafico a punti mostra che otto funzionari ritengono che il taglio dei tassi l’anno prossimo sarà inferiore a 75 punti base, mentre cinque funzionari si aspettano che sia ancora maggiore. Questo è il “Dot Plot” più caotico che sia apparso in molti anni.</p>
<p>Poiché la Federal Reserve si sposta verso una posizione accomodante e il mercato diventa più accomodante, ora è quotato un taglio dei tassi di interesse di 150 punti base nel 2024 (anno delle elezioni). Poiché Powell non ha risposto al recente taglio dei tassi di interesse, i bond del tesoro statunitense sono schizzati in alto, le azioni statunitensi sono aumentate e i trader hanno aumentato le loro scommesse sul taglio dei tassi di interesse a marzo a un livello quasi certo (75%).</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttrice: 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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>