Tm90aXppZSBxdW90aWRpYW5lIHwgSnVzdGluIFN1biBoYSBsYW5jaWF0byBCaXRjb2luIExheWVyMjsgTWljcm9TdHJhdGVneSBkZXRpZW5lIG9sdHJlICQxMCBtaWxpYXJkaSBpbiBCVEM7IEJsYXN0IFRWTCBzdXBlcmEgJDEsNyBtaWxpYXJkaTsgU0VJIHN1cGVyYSAkMSwgc3RhYmlsZW5kbyB1biBudW92byBtYXNzaW1vIHN0b3JpY28

2024-02-16, 03:23

<p><img src="https://gimg2.gateimg.com/image/article/17080536631_10.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Justin20Sun20ha20lanciato20Bitcoin20Layer220Blast20TVL20supera201720miliardi20di20dollari226732"><a name="Riepilogo giornaliero delle criptovalute: Justin Sun ha lanciato Bitcoin Layer2, Blast TVL supera $1.7 miliardi di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: Justin Sun ha lanciato <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Layer2, Blast TVL supera $1.7 miliardi di dollari</h2><p>Il 15 febbraio, secondo il monitoraggio di Arkham, Grayscale ha trasferito 2399.657 BTC all’indirizzo di Coinbase Prime, equivalente a circa 126 milioni di dollari. Inoltre, Grayscale ha trasferito 1756.294 BTC a un nuovo indirizzo, sospettato di essere il nuovo indirizzo fiduciario di Grayscale.</p>
<p>Secondo un rapporto della società di analisi dei dati on-chain CryptoQuant del 14 febbraio, oltre tre quarti dei nuovi <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli investimenti delle ultime due settimane provengono da Bitcoin spot ETF, escludendo grayscale GBTC. Il rapporto afferma: “stimiamo che oltre il 75% dei nuovi investimenti in Bitcoin provengano da questi ETF. Inoltre, misurati dal valore di mercato realizzato, gli investimenti da questi ETF sono aumentati al 2% dell’investimento totale storico in Bitcoin in solo un mese.”</p>
<p>Con la crescita dell’ecosistema Bitcoin, Justin Sun ha iniziato a entrare nel Layer2 di Bitcoin.</p>
<p>Ieri, Justin Sun ha annunciato ufficialmente <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> Lancio di una soluzione Bitcoin Layer 2 e di una roadmap, con l’obiettivo di migliorare l’interoperabilità tra le reti Bitcoin e TRON.</p>
<p>TRON pianifica di integrare token all’interno della rete TRON, inclusi stablecoin con un valore di mercato di 55 miliardi di dollari, con la rete Bitcoin e la sua struttura di livello 2, come Bitcoin ordinale, tramite la sua soluzione di livello 2 per promuovere l’accesso agli asset cross-chain e migliorare la vitalità finanziaria.</p>
<p>La roadmap è composta da tre fasi: espandere il ponte dagli asset di Bitcoin a <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a> nella fase α; collaborare con il protocollo di livello 2 di Bitcoin nella fase β; Annunciare una soluzione di secondo livello per l’integrazione delle reti TRON, BTTC e Bitcoin nella fase γ. Questo piano mira a mantenere la velocità e il basso costo dei sistemi POS garantendo la sicurezza di POW&amp;UTXO, segnando un passo importante per TRON nel migliorare l’interoperabilità e la praticità della tecnologia blockchain.</p>
<p>Secondo Bloomberg, le riserve di Bitcoin di MicroStrategy valgono attualmente 10 miliardi di dollari. In precedenza, Michael Saylor, fondatore di MicroStrategy, ha dichiarato in un’intervista con CNBC che, con l’aumento del prezzo del Bitcoin a 50000 dollari, i profitti non realizzati di MicroStrategy dagli investimenti in Bitcoin hanno raggiunto circa 3.5 miliardi di dollari. Da quando ha acquistato Bitcoin nel 2020, l’azienda ha detenuto un totale di 190.000 Bitcoin, con un costo medio di acquisto di 31.224 dollari e un costo totale di circa 5.93 miliardi di dollari.</p>
<p>Telefonica, una compagnia di telecomunicazioni spagnola, ha annunciato giovedì la creazione di una alleanza strategica con Chainlink Labs, un fornitore di soluzioni Web3. Attraverso la collaborazione, le due aziende si impegnano ad integrare funzioni di telecomunicazioni del mondo reale nelle reti blockchain per migliorare la sicurezza. Il primo caso d’uso della partnership coinvolgerà il SIM SWAP API, introdotto dalla Global Association of Mobile Communications s Open Gateway (una rete mobile che fornisce interfacce programmabili per gli sviluppatori). Telefonica è un membro di GSMA.</p>
<p>OpenAI ha annunciato il lancio di un nuovo sistema di intelligenza artificiale chiamato Sora, in grado di creare fino a un minuto di video realistici basati su prompt di testo. Questi video possono mostrare scene complesse che contengono più personaggi, azioni e temi e sfondi precisi. Il CEO di OpenAI, Sam Altman, ha dichiarato che questo strumento sarà inizialmente disponibile solo per alcuni creatori. Nel frattempo, l’azienda sta sviluppando nuovi strumenti per aiutare a individuare quali video sono stati generati da Sora come parte della valutazione della sicurezza e dei lavori di preparazione prima del lancio del prodotto.</p>
<p>Il 15 febbraio, secondo i dati di DeBank, il valore totale dell’asset del contratto Layer 2 della rete Blast lanciato dal fondatore di Blur Pacman ha raggiunto 1,764 miliardi di dollari, con circa 1,6 miliardi di dollari di ETH depositati nel protocollo Lido e oltre 147 milioni di DAI depositati nel protocollo Maker. Secondo il mercato di Gate.io, l’SEI del progetto di catena pubblica L1 ha ora superato 1 USDT, raggiungendo 1,03 dollari in un certo momento e ora riporta 1,01 dollari, con un aumento del 24 ore di oltre il 10%, fissando un nuovo massimo storico.</p>
<p>Il 16 febbraio, secondo i dati di Defi Llama, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il protocollo Restaking (TVL) basato su EigenLayer ha raggiunto 3,417 miliardi di dollari, con i primi tre protocolli che sono ether.fiTVL che ha raggiunto 1,216 miliardi di dollari, un aumento mensile del 392%; PufferFinance è stato online per metà mese, con un TVL di 968 milioni di dollari; KelpDAOTVL ha raggiunto i 461 milioni di dollari, con un aumento mensile del 172%.</p>
<h2 id="h2-Macro20Dati20misti20la20crescita20economica20potrebbe20rallentare20in20futuro928450"><a name="Macro: Dati misti, la crescita economica potrebbe rallentare in futuro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Dati misti, la crescita economica potrebbe rallentare in futuro</h2><p>Giovedì, il tasso mensile delle vendite al dettaglio negli Stati Uniti per gennaio è stato del -0,8%, inferiore al previsto -0,1%, con un valore precedente dello 0,60%, la maggiore caduta dal marzo 2023. Il tasso mensile dell’indice dei prezzi delle importazioni degli Stati Uniti a gennaio ha registrato lo 0,8%, previsto al 0%. Il valore precedente è stato rivisto al ribasso dallo 0% al -0,7%, il maggiore aumento dal marzo 2022. Il numero di richieste iniziali di sussidi di disoccupazione negli Stati Uniti per la settimana conclusasi il 10 febbraio è stato di 212.000, inferiore alle attese di 220.000, con il valore precedente salito da 218.000 a 220.000. La valutazione del mercato dei derivati riflette una maggiore facilitazione della politica della Federal Reserve nel 2024.</p>
<p>Dopo la pubblicazione dei dati sulle vendite al dettaglio, i prezzi del mercato dei swap riflettono il rilassamento della politica della Federal Reserve nel 2024. L’indice del dollaro statunitense è sceso di circa 20 punti nel breve termine. L’oro fisico è salito di quasi $6 nel breve termine, tornando sopra il livello di 2.000.</p>
<p>A causa dei dati economici misti negli Stati Uniti, l’indice del dollaro americano ha registrato un significativo calo durante la sessione di trading statunitense, ma è rimasto al di sopra del livello 104, chiudendo infine in ribasso dello 0,42% a 104,27, segnando il secondo giorno consecutivo di declino. Il rendimento del titolo del Tesoro USA decennale di riferimento è brevemente sceso al di sotto del livello del 4,2% durante il trading e poi è risalito al 4,233%. Il rendimento del titolo del Tesoro USA biennale, sensibile ai tassi di interesse, è rimasto pressoché invariato al 4,578%.</p>
<p>L’oro spot è tornato sopra la soglia dei $2.000 e ha raggiunto un massimo intraday di $2.008,36 durante le contrattazioni, chiudendo infine in rialzo dello 0,61% a $2.004,43 per oncia; l’argento spot è salito significativamente nel corso della giornata e ha brevemente superato i $23, chiudendo infine in rialzo del 2,46% a $22,92 per oncia.</p>
<p>I due petroli hanno ripreso leggermente. Il petrolio greggio WTI ha iniziato a salire nella sessione pre US, raggiungendo un massimo intraday di $78.04 durante la sessione di trading, per poi scendere leggermente prima di chiudere infine in rialzo dello 1.36% a $77.53 al barile; il petrolio greggio Brent ha chiuso in rialzo del 1.6% a $82.74 al barile.</p>
<p>L’indice del mercato azionario statunitense ha chiuso in rialzo dello 0,91%, l’indice S&amp;P 500 è salito dello 0,58% e il Nasdaq è salito dello 0,3%. Le azioni legate al concetto di blockchain hanno registrato in generale una chiusura in rialzo, con Coinbase (COIN.O) in aumento del 3,3%, Meta Platforms (META.O) in aumento del 2,27%, IBM (IBM.N) in aumento dell’1,78% e AMD (AMD.O) in aumento dell’1,09%.</p>
<p>A causa del freddo tempo negli Stati Uniti, i consumatori tendono a restare a casa, e la diminuzione delle vendite al dettaglio a gennaio ha superato di gran lunga le aspettative, sollevando dubbi su se la spesa dei consumatori all’inizio del nuovo anno possa continuare.</p>
<p>Il brusco calo delle vendite al dettaglio negli Stati Uniti a gennaio è stato principalmente trascinato al ribasso dal calo dei ricavi delle concessionarie auto e delle stazioni di servizio. Questo calo è avvenuto dopo una performance relativamente forte durante la stagione delle feste. Le vendite a dicembre sono state anche parzialmente influenzate da fattori stagionali. Le vendite al dettaglio non aggiustate tendono tipicamente a diminuire a gennaio.</p>
<p>L’economista di Morgan Stanley, Daniel Silver, ha detto: “È difficile sapere con certezza quali siano i fattori stagionali ‘corretti’ per un certo mese, ma rispetto ai fattori stagionali legati a questi due mesi negli anni precedenti, i fattori stagionali di dicembre 2023 e gennaio 2024 sembrano insoliti. Quando si cerca di determinare la tendenza dei dati, i singoli cambiamenti di aggiustamento stagionale in questi mesi potrebbero essere trascurati.”</p>
<p>Altre istituzioni ritengono che la pretesa di un’economia statunitense inaspettatamente forte sia stata distrutta dopo che i dati hanno mostrato un inatteso calo delle vendite al dettaglio. I dati sul CPI di martedì hanno indotto i trader a posticipare le scommesse sui tagli dei tassi di interesse, mentre i dati odierni indicano che la spesa dei consumatori si sta rallentando, il che è un segnale accomodante. Ciò porterà al ribasso il dollaro statunitense e potrebbe aumentare le azioni sensibili ai tassi di interesse.</p>
<p>I consumatori americani sono sotto pressione a causa dell’aumento dei tassi di interesse, dell’inflazione persistente e della difficoltà di accedere al credito, poiché i risparmi accumulati durante la pandemia si stanno esaurendo. Tuttavia, un punto luminoso è che il mercato del lavoro rimane in buone condizioni. La forte redditività delle principali aziende tecnologiche ha inoltre spinto al rialzo il mercato azionario, contribuendo ad aumentare la ricchezza di alcuni americani.</p>
<p>Nonostante una serie di licenziamenti notevoli di recente, principalmente nelle industrie tecnologiche e dei media, il numero di persone che richiedono sussidi di disoccupazione negli Stati Uniti si mantiene ancora a un livello basso. A causa del mercato del lavoro stretto, alcuni lavoratori licenziati potrebbero trovare facile trovare nuovi posti di lavoro. Durante e dopo la pandemia COVID-19, la maggior parte delle aziende è riluttante a licenziare i lavoratori perché trovano difficile colmare le vacanze.</p>
<p>Attualmente, non ci sono segni evidenti di recessione negli Stati Uniti, ma gli economisti prevedono generalmente che la crescita economica rallenterà nei prossimi mesi.</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 a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>