RGFpbHkgTmV3cyB8IEwnQXJnZW50aW5hIGFwcHJvdmEgaSBjb250cmF0dGkgZGkgcmVnb2xhbWVudG8gQml0Y29pbjsgQmxhY2tSb2NrIGhhIGxhIHByb2JhYmlsaXTDoCBwacO5IGFsdGEgZGkgb3R0ZW5lcmUgbCdhcHByb3ZhemlvbmUgcGVyIGdsaSBFVEYgc3VsbG8gc3BvdCBwZXIgcHJpbW87IElsIFRWTCBkZWxsJ2Vjb3Npc3RlbWE

2023-12-22, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/17032280291_16.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20lArgentina20approva20i20contratti20di20regolamento20in20Bitcoin20il20TVL20dellecosistema20SOL20continua20a20salire20significativamente458844"><a name="Riassunto giornaliero delle criptovalute: l’Argentina approva i contratti di regolamento in Bitcoin, il TVL dell’ecosistema SOL continua a salire significativamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: l’Argentina approva i contratti di regolamento in Bitcoin, il TVL dell’ecosistema SOL continua a salire significativamente</h2><p>Concentriamoci prima sugli aspetti regolatori positivi di alcuni paesi.</p>
<p>Secondo quanto riportato dai media, l’Argentina ha attualmente approvato l’uso di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> per liquidare contratti, insieme ad altre criptovalute e/o materie prime approvate, come ad esempio carne misurata in chilogrammi o latte misurato in litri.</p>
<p>Il 22 dicembre, il Ministro degli Esteri argentino Diana Mondino ha confermato la sua posizione ufficiale sull’accettazione di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> come accordo contrattuale in una dichiarazione rivoluzionaria, indicando la volontà del governo argentino di accettare e stabilire formalmente un accordo denominato in Bitcoin, affermando il riconoscimento legale di Bitcoin in Argentina.</p>
<p>Anche se i dettagli relativi all’attuazione e alle sfumature legali devono ancora essere delineati, la dichiarazione di Mondino segna un passo cruciale verso la legalizzazione del Bitcoin in Argentina. Questa mossa potrebbe anche fungere da catalizzatore di mercato e incoraggiare altri paesi a considerare misure simili per includere il Bitcoin nel loro quadro legale.</p>
<p>Secondo Cryptonews, il presidente russo Putin ha firmato una legge che incorpora il rublo digitale nelle leggi fiscali nazionali. La nuova legge ha aggiunto termini come “rublo digitale” e “portafoglio rublo digitale”, e consente anche a agenti di polizia e ad altre persone designate dal tribunale di “recuperare” i fondi CBDC dal portafoglio “quando non c’è abbastanza valuta fiat nel conto bancario del contribuente”.</p>
<p>Inoltre, la legge consente alle autorità fiscali di sospendere le transazioni dei portafogli digitali del rublo digitale. Gli ufficiali fiscali possono anche richiedere agli operatori di piattaforma di fornire documenti che provino che i fondi sono stati addebitati dal conto del contribuente e consentire agli ufficiali fiscali di trasferire i token confiscati al Ministero delle Finanze russo.</p>
<p>Ci sono stati gli ultimi progressi negli ETF spot di Bitcoin.</p>
<p>Recentemente, la giornalista di Fox Business Eleanor Terrett ha twittato che le fonti gli hanno rivelato che la SEC degli Stati Uniti sta tenendo una conferenza telefonica congiunta con potenziali emittenti di ETF per assicurarsi che ogni prodotto ETF spot di Bitcoin sia creato in contanti, e la SEC sta anche chiedendo agli applicant di rimuovere tutti gli indizi di rimborso fisico dai documenti di domanda.</p>
<p>Secondo le quote di scommessa sui siti di gioco d’azzardo americani, c’è un’alta probabilità che gli ETF Bitcoin spot vengano approvati entro il 10 gennaio dell’anno prossimo. BlackRock, la più grande società di gestione di fondi al mondo, ha posto come priorità fondamentale per l’azienda l’ottenimento dell’approvazione della SEC per il suo ETF Bitcoin spot e allo stesso tempo ha la probabilità più alta di essere la prima a presentare la richiesta di approvazione.</p>
<p>Il fondatore e CEO di BlackRock, Larry Fink, una volta ha definito il Bitcoin come “un bene internazionale” e “un mezzo di conservazione del valore”, paragonabile allo status a lungo termine dell’oro. Si riporta che BlackRock abbia oltre 400 ETF tradizionali sul mercato e si sia incontrato con la SEC cinque volte riguardo alla sua domanda di ETF Bitcoin spot, l’ultima delle quali è avvenuta martedì scorso.</p>
<p>Anche se il recente calore del mercato è stato sottratto dall’ecosistema di Bitcoin, l’aggiornamento più importante di Denchun che <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sta per arrivare merita comunque l’attenzione di tutti.</p>
<p>Secondo CoinDesk, gli sviluppatori di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> stanno intensificando i test per l’aggiornamento Denchun dell’anno prossimo, che rappresenta una pietra miliare significativa mirata ad aumentare la capacità di archiviazione dei dati attraverso un nuovo processo chiamato “proto-dank sharding”. Gli sviluppatori hanno discusso dei loro obiettivi durante una riunione bisettimanale e pianificano di eseguire Dencun sulla rete di test Goerli il 17 gennaio. Si prevede che questo aggiornamento ridurrà il costo del Rollup del secondo livello e espanderà la blockchain aumentando i “blobs” di dati.</p>
<p>Gli sviluppatori stanno sviluppando un programma di test per l’aggiornamento di Denchun, con l’intenzione di eseguirlo sulla testnet di Sepolia il 31 gennaio e sulla rete di testing di Holesky il 7 febbraio. Ci si aspetta che le modifiche saranno implementate sulla mainnet entro la fine di febbraio. Queste date potrebbero cambiare a causa dei risultati della biforcazione della rete di test.</p>
<p>Inoltre, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema sta iniziando a prosperare. Secondo quanto riportato dai media, il progetto meme ecologico <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Bonk ha annunciato sulla piattaforma X che i biglietti in prevendita per il Solana Annual Summit Breakpoint 2024 saranno disponibili per l’acquisto utilizzando BONK, e la prevendita terminerà il 5 gennaio. Secondo gli ultimi dati di mercato di Gate.io, BONK è salito del 3,09% in 24 ore ed è attualmente quotato a $ 0,00002013. I token SOL invece vanno contro la tendenza, con un aumento del 17,10% in 24 ore e una quotazione attuale di $ 96,86.</p>
<p>Il 21 dicembre, il TVL (Total Value Locked) della rete Solana è salito a 1,22 miliardi di dollari, e c’è stato un aumento significativo del TVL per diversi protocolli nell’ecosistema Solana. Tra questi, il protocollo di staking di liquidità Jito ha raggiunto un TVL di 578 milioni di dollari, con un aumento settimanale del 23,32%; Il platform di prestito marginfi ha raggiunto un TVL di 330 milioni di dollari, con un aumento settimanale del 36,27%; La soluzione di liquidità Kamino ha raggiunto un TVL di 190 milioni di dollari, con un aumento settimanale del 49,64%.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi227203"><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-BTC345874"><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/1703228233BTC.png" alt=""><br>Questa settimana ha continuato a oscillare a livelli elevati e si è convergente, e il trend a breve termine ha ancora formato una struttura a W-inferiore. Prestare attenzione al fenomeno di divergenza a breve termine. Le fughe continueranno a vedere due massimi: $45.345 e $47.990; Xiaguan consiglia di mantenere due supporti: $40.280 e 38.399. Dollaro.</p>
<h3 id="h3-ETH400463"><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/1703228249ETH.png" alt=""><br>Il massimo di questa settimana ha continuato a oscillare sopra i 2.135 dollari statunitensi. Ha superato il trend al ribasso a breve termine. Rispetto ai settori principali, è ancora un segnale di bassa pressione. L’obiettivo a medio termine è ottimista riguardo al raggiungimento del livello di 2.489 dollari statunitensi e del livello di 2.838 dollari statunitensi. Si può utilizzare la disposizione strategica del rapporto tra profitti e perdite, mantenendo il supporto a breve termine a $2.135.</p>
<h3 id="h3-BAND316457"><a name="BAND" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BAND</h3><p><img src="https://gimg2.gateimg.com/image/article/1703228275BAND.png" alt=""><br>La linea giornaliera ha superato il grande trend al ribasso e nel breve termine ha raggiunto la fine della convergenza. Allo stesso tempo, ha superato due livelli di supporto: $1.316 e $1.179. Si consiglia di mantenere stabile il prezzo di base e l’obiettivo a lungo termine continuerà ad essere $3.36, $6.09 e $7.30, 11.235 dollari e il massimo precedente di 23.28 dollari, c’è un considerevole margine per una posizione a lungo termine.</p>
<h2 id="h2-Macro20lindice20del20PIL20degli20Stati20Uniti20delude20le20aspettative20con20una20probabilit20di20circa20l8020di20tagli20dei20tassi20di20interesse20a20marzo953513"><a name="Macro: l’indice del PIL degli Stati Uniti delude le aspettative, con una probabilità di circa l’80% di tagli dei tassi di interesse a marzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: l’indice del PIL degli Stati Uniti delude le aspettative, con una probabilità di circa l’80% di tagli dei tassi di interesse a marzo</h2><p>Alle 21:30 ora di Pechino di giovedì, il tasso di crescita annuale trimestrale reale del PIL per il terzo trimestre degli Stati Uniti è stato registrato al 4,9%, inferiore al previsto 5,20%. Il tasso effettivo di consumo personale trimestrale nel terzo trimestre degli Stati Uniti è stato registrato al valore finale del 3,1%, inferiore al previsto 3,6%. Il tasso annuale trimestrale dell’indice dei prezzi core PCE nel terzo trimestre degli Stati Uniti è stato registrato al valore finale del 2%, inferiore al previsto 2,30%. Il numero di domande iniziali per sussidi di disoccupazione negli Stati Uniti per la settimana che termina il 16 dicembre è stato registrato a 205.000, inferiore al previsto 215.000.</p>
<p>Giovedì, l’indice del dollaro americano è sceso bruscamente prima del mercato statunitense, scendendo sotto quota 102 e raggiungendo un minimo di una settimana a 101,73, chiudendo infine in ribasso dello 0,59% a 101,79. I rendimenti dei titoli di stato americani sono prima scesi e poi risaliti, con il rendimento del titolo a 10 anni che è sceso a un minimo di quasi 5 mesi del 3,829% prima di riprendersi e chiudere infine al 3,892%; Il rendimento del titolo a due anni del Tesoro degli Stati Uniti, che è più sensibile ai tassi di interesse della Federal Reserve, ha chiuso al 4,352%. I tre principali indici azionari statunitensi hanno aperto in rialzo e chiuso in rialzo, con il Dow Jones in aumento dell’0,87%, l’indice S&amp;P 500 in aumento dell’1,03% e il Nasdaq Composite in aumento dell’1,26%.</p>
<p>L’oro spot ha nuovamente recuperato dai livelli di $2.030 e $2.040 ed è salito brevemente a un massimo intraday di $2046.04, chiudendo infine in rialzo dello 0,73% a $2.043,02 per oncia; l’argento spot è salito dell’1,06% chiudendo a $24,4 per oncia.</p>
<p>A causa dell’annuncio dell’Angola del suo ritiro dall’OPEC, ciò ha ulteriormente suscitato preoccupazioni sul fatto che i tagli alla produzione dell’OPEC+ non potessero sostenere il mercato del petrolio, con il greggio internazionale che prima è sceso e poi è risalito. Il greggio WTI è sceso fino a un minimo intraday di $72.41 in un punto, per poi riprendersi e chiudere infine in rialzo dello 0.22% a $73.90 al barile; il greggio Brent è sceso fino a un minimo intraday di $77.79 durante le contrattazioni, per poi recuperare tutto il terreno perso e rialzarsi, chiudendo infine in rialzo dello 0.3% a $79.35 al barile.</p>
<p>La revisione al ribasso di una serie di dati economici ha consolidato la prospettiva di un taglio dei tassi d’interesse della Federal Reserve. Il rendimento del titolo di stato decennale è sceso al 3,84%, il livello più basso dal 27 luglio. L’indice del dollaro statunitense è sceso al di sotto del livello di 102, toccando un minimo di 101,82. Il prezzo dell’oro è salito di oltre $10 nel breve termine dopo la pubblicazione dei dati, attestandosi a $2040 l’oncia, mentre l’argento è salito di $0,1 nel breve termine. Le valute non statunitensi sono generalmente salite, con l’euro che si è attestato a 1,10 rispetto al dollaro statunitense e il dollaro statunitense che è sceso dell’1% rispetto allo yen giapponese nell’arco della giornata. I futures dell’indice S&amp;P 500 e i futures del Nasdaq hanno continuato la loro tendenza al rialzo, raggiungendo i massimi pre-mercato.</p>
<p>Una serie di revisioni dei dati economici hanno consolidato la prospettiva di tagli dei tassi di interesse. Secondo l’Osservazione della Federal Reserve del CME, la probabilità che la Federal Reserve mantenga i tassi di interesse nell’intervallo del 5,25% -5,50% a febbraio dell’anno prossimo è dell’85,5%, e la probabilità di un taglio dei tassi di interesse di 25 punti base è del 14,5%. La probabilità di mantenere i tassi di interesse invariati entro marzo dell’anno prossimo è del 17,1%, la probabilità di un taglio cumulativo dei tassi di interesse di 25 punti base è del 71,3%, e la probabilità di un taglio cumulativo dei tassi di interesse di 50 punti base è dell’11,6%. Alcuni analisti suggeriscono anche che la probabilità che la Federal Reserve tagli i tassi di interesse a marzo dell’anno prossimo possa tornare a superare l’80%.</p>
<p>I dati PCE pubblicati oggi e venerdì si prevede che confermino che il tasso di inflazione degli ultimi sei mesi potrebbe tornare all’obiettivo di inflazione annuale della Fed del 2%. Pertanto, i dati dei prossimi sei mesi potrebbero essere altrettanto lenti, il che contribuirà a consolidare la giustificazione per i tagli ai tassi di interesse della Fed nei prossimi trimestri.</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 suggerimenti 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 a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>