Z2F0ZSBJbnNpZ2h0IElzdGl0dXppb25hbGUgU2V0dGltYW5hbGUgKDE4IGRpY2VtYnJlIDIwMjMp

<h2 id="h2-Panoramica20macroeconomica3466"><a name="Panoramica macroeconomica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica macroeconomica</h2><p><strong>I record di mercato statunitensi mentre la Fed segnala tagli ai tassi; ottimismo sull’inflazioneL’islam pre: </strong>Il mercato azionario statunitense ha raggiunto livelli record con il Dow, lo S&amp;P 500 e il Nasdaq che hanno assicurato la loro serie vincente più lunga dal 2017. Le piccole capitalizzazioni hanno registrato un forte aumento, tirando fuori l’indice Russell 2000 dal territorio dell’orso. L’attività degli investitori è aumentata, favorendo le azioni con un interesse breve, mentre il VIX ha toccato minimi post-COVID. Gli indicatori favorevoli sull’inflazione e il segnale della Fed di consistenti tagli dei tassi nel 2024 hanno rafforzato la fiducia del mercato. Le vendite al dettaglio sono aumentate inaspettatamente, ma la produzione ha mostrato debolezza. I rendimenti dei titoli del Tesoro a lungo termine sono scesi al di sotto del 4%, mentre le obbligazioni societarie hanno registrato un’impennata dopo la posizione accomodante della Fed.</p>
<p>Aspettative sui tassi e difficoltà economiche nella zona euro: una storia di dinamiche di mercato: lo STOXX Europe 600 è salito dello 0,92%, prevedendo tagli dei tassi nel 2024 da parte delle principali banche centrali. Il CAC 40 francese ha guadagnato; il DAX tedesco e il FTSE MIB italiano sono diminuiti, mentre il FTSE 100 del Regno Unito è salito dello 0,29%. La Banca centrale europea ha mantenuto il tasso di deposito al 4,0%, ma ha ridotto le previsioni di crescita e inflazione per il 2023 e il 2024. L’attività commerciale nella zona euro si è contratta, con un PMI del 47,0 a dicembre. La Bank of England ha mantenuto il tasso di riferimento del 5,25%, pronta ad aumentare se l’inflazione persiste. L’economia del Regno Unito è diminuita dello 0,3% in ottobre dopo un aumento dello 0,2% a settembre. La Norges Bank ha aumentato i tassi al 4,5%, puntando alla stabilità fino alla fine del 2024. La Swiss National Bank ha mantenuto un tasso del 1,75%, riducendo le previsioni di inflazione per il 2024 e il 2025.</p>
<p><strong>Le paure della deflazione gravano sulle azioni cinesi in mezzo a segnali economici contrastanti:</strong> Le azioni cinesi hanno subito cali a causa delle preoccupazioni deflazionistiche che hanno colpito il panorama economico. Lo Shanghai Composite e il CSI 300 sono diminuiti, mentre l’indice Hang Seng di Hong Kong è aumentato durante un rally dei mercati globali a seguito della posizione della Fed sui tassi di interesse. L’indice dei prezzi al consumo della Cina è diminuito dello 0,5% a novembre, con un contributo dei prezzi più bassi del maiale, mentre l’indice dei prezzi alla produzione ha registrato una diminuzione del 3% su base annua, sollevando preoccupazioni su un ciclo deflazionistico. I dati economici di novembre hanno presentato uno scenario misto: la produzione industriale ha superato le aspettative, le vendite al dettaglio sono aumentate ma hanno mancato le previsioni e gli investimenti in attività fisse sono rimasti più deboli del previsto. Nonostante alcuni indicatori positivi, le preoccupazioni persistevano, portando la Banca Popolare Cinese ad iniettare fondi nel sistema bancario, mantenendo gli sforzi per contrastare le sfide economiche. Gli analisti prevedono ulteriori supporti di politica nel 2024, poiché il governo mira a stimolare il consumo interno e gli investimenti, affrontando rischi persistenti come la debole fiducia dei consumatori e il settore immobiliare in difficoltà, come delineato durante la Conferenza Economica Centrale.<br><img src="https://gimg2.gateimg.com/image/17032342931845989131.png" alt=""><br>DXY</p>
<p>Il DXY lotta con l’instabilità, oscillando sopra il livello 102,50 dopo aver rimbalzato da un recente minimo. I rendimenti dei titoli del Tesoro statunitense a breve termine hanno offerto un certo supporto al Greenback, tuttavia i dati misti del PMI di dicembre hanno creato incertezza. Mentre il PMI dei servizi ha segnalato la crescita, il PMI manifatturiero ha indicato la contrazione. Ora l’attenzione si sposta sulla fiducia dei consumatori e sul cambiamento delle vendite di case esistenti per ulteriori indicazioni.</p>
<p>Commenti accomodanti da parte dei funzionari della Fed, tra cui il Presidente della Fed di Atlanta Raphael Bostic che lascia intendere un potenziale taglio dei tassi nel terzo trimestre del 2024 e il Presidente della Fed di Chicago Austan Goolsbee che non esclude un taglio dei tassi nel meeting della Fed di marzo, potrebbero esercitare pressione al ribasso sul dollaro USA nelle prossime sessioni.<br><img src="https://gimg2.gateimg.com/image/17032343523237787642.png" alt=""><br>US10Y<br><img src="https://gimg2.gateimg.com/image/17032343934824315903.png" alt=""><br>US02Y<br><img src="https://gimg2.gateimg.com/image/17032343932672766304.png" alt=""><br>Il gap negativo tra US10Y e US02Y</p>
<p>Il rendimento del bond statunitense a 2 anni è migliorato al 4.48% venerdì ma è sceso al 4.43% al momento della scrittura lunedì. Mentre il rendimento del bond statunitense a 10 anni si attesta al 3.92%.</p>
<p><img src="https://gimg2.gateimg.com/image/17032344581778484755.png" alt=""><br>Oro</p>
<p>Nella sessione asiatica di lunedì, l’oro mantiene la stabilità intorno a $2.020 dopo una settimana turbolenta conclusasi con un notevole ritracciamento venerdì. Mentre il mercato si avvicina alla fase pre-natalizia, il prezzo dell’oro aspetta il cruciale rapporto sull’inflazione statunitense, destinato a influenzare la rivalutazione delle aspettative riguardo ai tagli dei tassi d’interesse della Federal Reserve statunitense per l’anno prossimo. Nonostante il ritiro di venerdì dai massimi di otto giorni a $2.048, la traiettoria prente per l’oro continua a inclinarsi verso un momento di crescita.</p>
<hr>
<h2 id="h2-Panoramica20dei20mercati20crittografici831827"><a name="Panoramica dei mercati crittografici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica dei mercati crittografici</h2><p><strong>1. Bitcoin</strong> <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Rete Casper</a> <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Prezzo<br><img src="https://gimg2.gateimg.com/image/17032345729559224657.png" alt=""><br>Dominanza di Bitcoin</p>
<p>Bitcoin si stabilizza tra i $41.500 e i $43.000 dopo il recupero dalla recente vendita post-dati sul CPI degli Stati Uniti. Le analisi on-chain suggeriscono uno spostamento di 5.000 BTC lontano dagli scambi e dai portafogli di trading durante il fine settimana, suggerendo potenziali strategie degli investitori. Gli indicatori tecnici enfatizzano livelli di resistenza cruciali che BTC deve superare per far riprendere forza al momentum rialzista nella prossima settimana.<br><img src="https://gimg2.gateimg.com/image/17032346551532866208.png" alt=""><br>Prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> vs. DXY</p>
<p>Continuando la correlazione negativa tra DXY e il prezzo di Bitcoin, DXY è aumentato mentre BTC è sceso nella scorsa settimana.</p>
<p><strong>2.Ethethereum</strong></p>
<p><img src="https://gimg2.gateimg.com/image/17032347505209548689.png" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Prezzo</p>
<p>Il prezzo di ETH è rimasto scambiato intorno al livello di supporto cruciale di $2.200. Il prezzo è sceso sotto i $2.200 di tanto in tanto, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> deve evitare una chiusura sostenuta al di sotto della zona di supporto cruciale di $2.100. Da settimana scorsa, i movimenti dimostrano una continua volatilità nel mercato ETH, mostrando rischi e fluttuazioni sostanziali nel breve termine.<br><img src="https://gimg2.gateimg.com/image/170323475019220267810.png" alt=""><br>Daily ETHBTC<br><img src="https://gimg2.gateimg.com/image/170323486823007823311.png" alt=""><br>ETHBTC settimanale</p>
<p>Il rapporto ETHBTC giornaliero è continuato ad essere scambiato nell’intervallo 0,053-0,055.</p>
<p><strong>3. Capitalizzazione di mercato totale</strong><img src="https://gimg2.gateimg.com/image/170323486874256613912.png" alt=""><br>Crypto Capitalizzazione totale di mercato<br>Questa settimana, la capitalizzazione di mercato globale delle criptovalute ha continuato a essere scambiata intorno a 1,51 trilioni di dollari, una diminuzione del -1,3% rispetto al livello della settimana scorsa.</p>
<p><strong>4. Flussi di stablecoin</strong><img src="https://gimg2.gateimg.com/image/170323502575357604513.png" alt=""><br>Capitalizzazione di mercato totale delle Stablecoin, Fonte: Defillama<br><img src="https://gimg2.gateimg.com/image/170323502575357604513.png" alt=""><br>Capitalizzazione di mercato delle principali stablecoin, Fonte: Defillama</p>
<p>Nell’ultima settimana, la capitalizzazione di mercato di USDT ha registrato un altro aumento maggiore rispetto ai mesi precedenti, mentre la capitalizzazione di mercato di USDC ha subito un lieve calo e poi un aumento. La capitalizzazione di mercato combinata delle stablecoin è ora intorno al livello di $ 129,5 miliardi, simile al livello della scorsa settimana.</p>
<p><strong>5. Prestazioni dei primi 30 asset crittografici</strong><img src="https://gimg2.gateimg.com/image/17032351029641947815.png" alt=""><br>Fonte: Coingecko e Gate Ventures, al 18 dicembre 2023</p>
<p>Nelle ultime 7 giorni, i primi 30 asset criptati hanno registrato alcune impennate dei prezzi. BIl prezzo di Bitcoin è diminuito del -2,8% e Ethereum è diminuito del -3,0%. ICP guida la classifica con una crescita dell’82,9% beneficiando del suo InComp di TernetIniziativa airdrop di $ICP tramite Gate.</p>
<p><strong>I Momenti Salienti della Crypto Chiave</strong></p>
<p><strong>1.Evidenze</strong></p>
<p>1) Solinions: Un approccio rivoluzionario all’energia solareArtefatti digitali di na</p>
<p>Solinions rappresentano una significativa novità nel campo della creazione e della condivisione di artefatti digitali specificamente progettati per il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain. Queste innovative Solinions ridefiniscono il panorama degli artefatti digitali su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> sfruttando la caratteristica unica nota come ‘memo’, diversa da quella di Ethereum, chiamata Ethions.</p>
<p>Solinions operano come un’implementazione open-source di un protocollo che sfrutta il potere del memo Solana. Questo sviluppo trasformativo mostra l’evoluzione dell’ecosistema digitale Solana.</p>
<p>Solinions funziona come un protocollo efficiente in termini di costi, consentendo la condivisione di informazioni e calcoli su Solana Layer 1. Si discostano dagli smart contract convenzionali e dalle soluzioni centralizzate Layer 2, offrendo un’alternativa economica. Utilizzando il memo Solana, Solinions aggira la necessità di archiviazione ed esecuzione di smart contract, eseguendo le modifiche di stato attraverso regole di protocollo deterministiche. Ciò evidenzia l’efficienza e le capacità uniche insite nella funzione memo di Solana.</p>
<p>Nel suo nucleo, Solinions mira a democratizzare le computazioni decentralizzate, rendendo le attività blockchain accessibili agli utenti di tutti i giorni a un costo accessibile.</p>
<p>Attualmente, le Solinions servono come alternativa economica alle Non-Fungible Tokens (NFT) nell’ecosistema Solana. Guardando avanti, mirano a evolversi in un’alternativa economica ai tradizionali smart contract Solana, ampliando così le opportunità per gli utenti che navigano il panorama della blockchain Solana.</p>
<p>2) OpenChat avvia l’autenticazione del riconoscimento facciale per la convalida umana</p>
<p>OpenChat, un’applicazione di chat decentralizzata che utilizza Dfinity’s <a href="/price/internet-computer-icp" rel="nofollow noopener noreferrer" target="_blank">Internet Computer</a> blockchain e vantandosi di oltre 100.000 utenti, è pronto a sperimentare un sistema di autenticazione facciale che convalida l’umanità degli utenti, secondo quanto riportato da The Block. La piattaforma mira a favorire conversazioni più etiche obbligando gli utenti a confermare la propria identità umana singolare, con l’intento di limitare le attività fraudolente e promuovere un discorso virtuoso sulle app.</p>
<p>Sebbene verificare l’umanità rimanga semplice, affermare identità umane uniche comporta una maggiore complessità e potrebbe scoraggiare pratiche come il token farming o gli airdrop condotti tramite account multipli.</p>
<p>In questa fase iniziale, OpenChat non applicherà universalmente il processo di verifica, ma le future iterazioni potrebbero adottare una posizione diversa. Divergendo dagli indirizzi email e nomi utente convenzionali, la piattaforma sfrutta gli indirizzi crittografici e gli NFT per l’autenticazione e incentiva il coinvolgimento.</p>
<p>Questa iniziativa segue la collaborazione di OpenChat con Modclub, un servizio di moderazione dei contenuti decentralizzato. La partnership sposta la responsabilità della moderazione dai leader dei gruppi di chat ai moderatori di Modclub, che ricevono criptovalute come compenso, sottolineando un passaggio verso una governance guidata dalla comunità e una supervisione decentralizzata dei contenuti.</p>
<p>3) <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> Labs’ Shift: From <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Edge to ZK-Powered <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> CDK</p>
<p>Polygon Labs, fondamentale nelle reti di scalabilità di Ethereum, ha abbandonato “Polygon Edge” a favore di “Polygon CDK”, un kit di sviluppo blockchain che utilizza la crittografia a conoscenza zero. Questa mossa denota la discontinuità del supporto a Polygon Edge, precedentemente utilizzato da Dogechain in un tentativo non ufficiale di stabilire una Drete di contratti intelligenti centrata su dogecoin.</p>
<p>Mentre Dogechain cercava di utilizzare Polygon Edge per <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> Nelle transazioni, questo sforzo mancava del supporto ufficiale del progetto Dogecoin. Polygon Labs ha ora interrotto i contributi a Polygon Edge, indirizzando il loro supporto a Polygon CDK. Sottolineando il loro impegno, lo sviluppatore evidenzia il ruolo di CDK nella creazione di blockchain di livello 2 che utilizzano la crittografia a conoscenza zero, una tecnologia che sta guadagnando terreno tra i progetti crypto.</p>
<p>In un post sul blog, Polygon Labs ha svelato il loro cambiamento strategico, sottolineando l’avanzamento all’interno dell’ecosistema di Polygon. Questa transizione sottolinea la loro attenzione su Polygon CDK, un framework che consente agli sviluppatori di costruire reti di livello 2 modellate secondo la tecnologia a conoscenza zero, una mossa fondamentale che indica il loro allontanamento da Polygon Edge.</p>
<p><strong>2. Affari chiave di investimento</strong><br>1) Il protocollo Bitcoin, bitSmiley, è stato finanziato da OKX e ABCDE</p>
<p>bitSmiley, che promuove il potenziale di Bitcoin, dà il via a una nuova fase con un investimento alpha co-leaded da OKX Ventures e ABCDE Labs. La collaborazione mira a elevare la missione di BTC espandendo bitSmiley, un protocollo in crescita all’interno della blockchain di Bitcoin. bitSmiley è un pioniere di uno Stablecoin decentralizzato, prestiti senza fiducia e derivati nell’ambito del framework Fintegra. Il prodotto principale, bitUSD, sostiene la stabilità e la trasparenza all’interno della blockchain di Bitcoin. bitLending per prestiti peer-to-peer e un segmento Credit Default Swaps (CDS) arricchiscono ulteriormente il panorama Bitcoin DeFi.</p>
<p>2) Farcana, un gioco di arena per PC, ha raccolto $10m da Animoca, Polygon, ecc.</p>
<p>Farcana, lo sparatutto arena per PC che integra un’economia Web3, garantisce $10 milioni in finanziamenti Seed da Animoca Brands, Polygon Ventures e altri. Farcana Studio, con sede negli Emirati Arabi Uniti, presenta uno sparatutto basato sul lavoro di squadra che enfatizza il gameplay strategico e un sistema di premi in Bitcoin. Sviluppato su Unreal Engine 5, offre funzionalità innovative come gli ordinali di Bitcoin “Free Mint” all’interno dei giochi AAA Web3. Tornei competitivi, una battaglia reale ambientata su Marte e un modello deflazionistico Play-to-Hash fanno parte dell’esperienza coinvolgente di Farcana.</p>
<p>3) Andalusia Labs ha raccolto $48 milioni da Lightspeed, Mubadala, ecc.</p>
<p>Andalusia Labs (ex Risk Harbor), un provider di gestione del rischio degli asset digitali, raccoglie $48 milioni nella Serie A guidata da Lightspeed, con Mubadala Capital e altri importanti sostenitori. Offrendo soluzioni come la blockchain Karak di livello 2 e il marketplace di gestione del rischio criptografico Subsea, Andalusia Labs si propone di stabilire standard di sicurezza e integrare la blockchain nei servizi finanziari globali.</p>
<p>4) LINE NEXT ha ottenuto $140 milioni guidati dalla società di private equity Crescendo<br>LINE NEXT (DOSI), una piattaforma globale NFT, ha ottenuto $140 milioni guidati da Crescendo Equity Partners. DOSI mira a colmare <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e le funzionalità web esistenti. Offrendo metodi di pagamento user-friendly e PFP NFT unici, i cittadini di DOSI partecipano a un programma di adesione basato su NFT, promuovendo un ecosistema vibrante per creatori e aziende in tutto il mondo.</p>
<p>Il numero di affari chiusi nella settimana precedente è stato di 33, con Infra in testa con 18 affari, pari al 55% del numero totale di affari. Il settore con il minor numero di affari è GameFi con 3 affari finanziati, che rappresentano il 9% del numero totale di affari della scorsa settimana.<br><img src="https://gimg2.gateimg.com/image/170323520623949276016.png" alt=""><br>Sommario settimanale degli affari di venture, Fonte: Cryptorank e Gate Ventures, al 18 dicembre 2023</p>
<p>L’importo totale dei finanziamenti raccolti nella settimana precedente è stato di $314.2 milioni, con il settore Sociale in testa con $141.3 milioni, che rappresentano il 45% del finanziamento complessivo. Il settore con il minor importo di finanziamenti nella settimana precedente è stato DeFi con $7.3 milioni raccolti, che rappresentano rispettivamente il 2% del finanziamento complessivo della settimana scorsa.<br><img src="https://gimg2.gateimg.com/image/170323523550363707817.png" alt=""><br>Sommario settimanale degli accordi di investimento, Fonte: Cryptorank e Gate Ventures, al 18 dicembre 2023</p>
<p>Anche se i valori della raccolta fondi hanno subito un significativo calo da agosto a causa di vari importanti eventi macro, un momento positivo è tornato alla fine di novembre. Il valore totale della raccolta settimanale è aumentato a $305.9m per le prime tre settimane di dicembre.</p>
<p>A presto la prossima settimana!</p>
<div class="blog-details-info"><br><div>Autore: Gate Venture<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div class="info-tips"><em></em>Nessun contenuto qui costituirà consulenza sugli investimenti e non costituisce alcuna offerta o sollecitazione di offerta o raccomandazione di alcun prodotto o progetto di investimento.<br><div class="info-tips"><em>L'inclusione di prodotti, servizi, entità o contenuti di terze parti non costituisce un'approvazione, una raccomandazione o un'affiliazione da parte di Gate.io. Si prega di condurre ricerche approfondite e di richiedere una consulenza professionale prima di prendere qualsiasi decisione di investimento.<br></em><div class="info-tips"><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>