Tm90aXppZSBxdW90aWRpYW5lIHwgTCdpc2NyaXppb25lIGRpIEJpdGNvaW4gc2VnbmF0YSBjb21lIHVuYSB2dWxuZXJhYmlsaXTDoCBkZWxsYSBzaWN1cmV6emEgaW5mb3JtYXRpY2E7IDEwIG5hcnJhemlvbmkgZGVnbmUgZGkgYXR0ZW56aW9uZSBkYWwgMjAyMyBhbCAyMDI0OyBBUFQsIEFQRSBlIGFsdHJpIHRva2VuIHNhcmFubm8gc2J

2023-12-11, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17022771091_6-07.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20le20iscrizioni20di20Bitcoin20contrassegnate20come20vulnerabilit20della20cibersicurezza201020narrazioni20degne20di20attenzione20dal20202320al20202482649"><a name="Riassunto giornaliero delle criptovalute: le iscrizioni di Bitcoin contrassegnate come vulnerabilità della cibersicurezza, 10 narrazioni degne di attenzione dal 2023 al 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: le iscrizioni di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> contrassegnate come vulnerabilità della cibersicurezza, 10 narrazioni degne di attenzione dal 2023 al 2024</h2><p>Il 9 dicembre, secondo quanto riportato da Cointelgraph, il National Vulnerability Database (NVD) degli Stati Uniti ha contrassegnato <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> iscrizioni come rischio per la sicurezza informatica, chiedendo attenzione alle vulnerabilità della sicurezza sviluppate da Ordinals Protocol nel 2022.</p>
<p>Secondo i record del database, in alcune versioni di Bitcoin Core e Bitcoin Knot, le limitazioni del supporto dati possono essere aggirate offuscando i dati nel codice. L’aggiunta all’elenco NVD significa che specifiche vulnerabilità della sicurezza della rete sono state identificate, catalogate e devono essere rese pubbliche. Questo database è gestito dal National Institute of Standards and Technology (NIST), una filiale del Dipartimento del Commercio degli Stati Uniti.</p>
<p>In precedenza, lo sviluppatore del client Bitcoin Core Luke Dashjr ha dichiarato che la vulnerabilità del client Bitcoin Core sfruttata dall’iscrizione è stata assegnata l’identificatore CVE-2023-50428.</p>
<p>L’11 dicembre, secondo The Block che cita i dati di Etherscan, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> congelato 161 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ieri sono stati creati 200 portafogli, di cui 150 attualmente non contengono USDT. Non è noto se <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> abbia posseduto USDT in passato e in quale quantità. In totale ci sono 11 indirizzi di portafogli che detengono oltre 3,5 milioni di USDT, di cui un singolo indirizzo detiene circa 3,4 milioni di USDT. ZachXBT ha collegato questo indirizzo all’attacco hacker recente subito da Stack.</p>
<p>Ieri Tether ha dichiarato che la società ha congelato i wallet personali sanzionati dall’Office of Foreign Assets Control (OFAC) negli Stati Uniti, con l’obiettivo di “prevenire in modo proattivo qualsiasi potenziale uso improprio dei token Tether e migliorare le misure di sicurezza”. Tether ha anche chiarito che i wallet esistenti nell’elenco OFAC saranno congelati e che anche tutti i nuovi wallet aggiunti in futuro saranno congelati.</p>
<p>Recentemente, Binance Labs ha rilasciato un rapporto che riassume le “10 narrazioni più significative.” Diamo un’occhiata a esse come riferimenti di investimento:</p>
<p>Fino ad ora, il valore di mercato totale delle criptovalute è aumentato del 110% quest’anno, il che significa che il capitale è aumentato di oltre 870 miliardi di dollari. Fino ad ora, il mercato è salito del 55% (circa 596 miliardi di dollari) nel quarto trimestre.</p>
<ol>
<li><p>L’offerta di stablecoin sta riprendendo, e per la prima volta dal primo trimestre del 2022, il cambiamento netto trimestrale nelle prime cinque offerte di stablecoin è diventato positivo.</p>
</li><li><p>Il volume di trading di NFT ha interrotto la tendenza al ribasso di 8 mesi, con un aumento mensile di quasi il 200% a novembre; Bitcoin è la catena più popolare, con transazioni NFT che superano i 375 milioni di dollari e superano addirittura gli NFT di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (348 milioni di dollari).</p>
</li><li><p>A novembre, i primi 20 progetti cripto hanno registrato un aumento dei costi, che è stato circa l’84% superiore rispetto ad ottobre e circa il 100% superiore rispetto a settembre. Anche il TVL di DeFi è aumentato, mentre la posizione dominante di DeFi è aumentata dell’18% rispetto al mese precedente.</p>
</li><li><p>Gli ordinali di Bitcoin e BRC-20 hanno di nuovo suscitato interesse a novembre e la notizia degli ETF spot di Bitcoin sembra ottimistica. Ci si aspetta che il mercato ottenga l’approvazione a gennaio e la diminuzione a metà di Bitcoin in aprile è un altro importante traguardo a cui prestare attenzione.</p>
</li><li><p>Recentemente, molte altre catene di Layer 1 hanno ottenuto risultati migliori di Ethereum, con importanti progressi in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>.</p>
</li><li><p>SocialFi ha introdotto nuovi protocolli come friend.tech, oltre a aggiornamenti a Farcaster, Lens e Binance Square.</p>
</li></ol>
<p>8.Gli RWA stanno diventando sempre più importanti, rappresentando attualmente oltre il 49% degli asset di MakerDAO in bilancio; Chainlink spera inoltre di stabilire una connessione più stretta tra TradFi, RWA e criptovalute attraverso la sua nuova soluzione CCIP.</p>
<p>La tecnologia a conoscenza zero sta decollando, di recente sono stati rilasciati vari ZK rollups, e il lavoro e le discussioni sui coprocessori ZK sono aumentati.</p>
<p>10.Il tasso di interesse degli Stati Uniti è al massimo degli ultimi 22 anni e il mercato si aspetta un taglio dei tassi l’anno prossimo.</p>
<p>Questo fine settimana, il progetto NFT di punta Pudgy Penguins ha improvvisamente cominciato a muoversi.</p>
<p>Il 10 dicembre, il progetto NFT Pudgy Penguins ha annunciato sui social media che Pudgy Penguins lancerà Pudgy World Alpha nel Q1 2024, supportato da zkSync.</p>
<p>Pudgy World è un luogo di gioco digitale interattivo fornito ai possessori di NFT Pudgy Penguins, ai possessori di giocattoli e ai principianti. Pudgy Penguins mira a portare agli utenti una nuova era di esperienze supportate da blockchain, con l’obiettivo di attirare milioni di persone. Pudgy World Alpha introdurrà nuovi personaggi Pudgy e Peaches.</p>
<p>Dopo l’annuncio, secondo i dati di mercato Blur, il prezzo minimo del progetto NFT “Fat Penguin” Pudgy Penguins ha superato i 12 ETH, con un prezzo minimo di 12,29 ETH e un aumento del 45,27% in 7 giorni.</p>
<p>Questa settimana, APT, CYBER, APE e altri token riceveranno un grande sblocco una tantum, con un valore totale di rilascio di circa $ 252 milioni. Tra di loro:</p>
<p>Alle 0:00 del 11 dicembre (UTC), <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> sbloccati 12.72 milioni di GLMR (circa $4.31 milioni), corrispondenti al 1.6% dell’offerta circolante;</p>
<p>Alle 0:00 am (UTC) del 12 dicembre, <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> sbloccherà 24,84 milioni di APT (circa 209 milioni di dollari), corrispondenti all’8,9% dell’offerta circolante;</p>
<p>Alle 4:19 del 15 dicembre, CyberConnect sbloccherà 1,26 milioni di CYBER (circa 8,71 milioni di dollari), pari all’8,51% dell’offerta circolante;</p>
<p>Alle 0:00 del 16 dicembre (UTC), <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> sbloccherà 2,6 milioni di <a href="/price/flow-flow" target="_blank" class="blog_inner_link">FLOW</a> (circa 2,18 milioni di dollari), corrispondenti allo 0,18% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 17 dicembre, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> sbloccherà 15,6 milioni di APE (circa 28,08 milioni di dollari), pari al 4,23% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi628626"><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-BTC941805"><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/1702277172BTC.png" alt=""><br>La scorsa settimana ha segnato sette chiusure consecutive rialziste dall’apertura. Il volume di trading a breve termine mostra segni di aver raggiunto il suo picco, anticipando un significativo ritracciamento questa settimana. Obiettivi di vendita allo scoperto: $40,495 e $38,975. Mantenere sopra i $37,980 è ancora considerato un segnale rialzista, ma un calo al di sotto richiede attenzione in quanto potrebbe indicare un passaggio da un trend rialzista a un trend ribassista.</p>
<h3 id="h3-ETH139873"><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/1702277191ETH.png" alt=""><br>L’andamento al rialzo della scorsa settimana ha raggiunto la neckline target a $2.381, toccando un massimo di $2.386. Se si verifica una correzione a livello di mercato, ci si aspetta un test di supporto a $2.135. Mantenere il livello sopra $1.951, anche durante un pullback, indica comunque un trend rialzista. A breve termine, potrebbero esserci opportunità sia per posizioni corte che lunghe.</p>
<h3 id="h3-INJ245748"><a name="INJ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>INJ</h3><p><img src="https://gimg2.gateimg.com/image/article/1702277214INJ.png" alt=""><br>La struttura del grafico giornaliero ha visto una crescita dal minimo di $1,225 alla resistenza storica di $24,999. Questa settimana si prevede che sfidi la resistenza più volte e stabilisca nuovi massimi con obiettivi a $37,828, $61,084 e $97,616. Questi tre livelli sono considerati condizioni per l’instaurazione di un mercato rialzista a lungo termine.</p>
<h2 id="h2-Macro20CPI20si20unisce20agli20attacchi20dei20dati20terroristici20e20questa20settimana20la20Federal20Reserve20dar20il20tono20per20il202024724000"><a name="Macro: CPI si unisce agli attacchi dei “dati terroristici”, e questa settimana la Federal Reserve darà il tono per il 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI si unisce agli attacchi dei “dati terroristici”, e questa settimana la Federal Reserve darà il tono per il 2024</h2><p>Il rapporto non agricolo di venerdì ha suggerito che il mercato del lavoro statunitense era più caldo e più resiliente di quanto Wall Street si aspettasse, minando le aspettative di mercato secondo cui la Federal Reserve avrebbe tagliato i tassi di interesse già a marzo dell’anno prossimo, sostenendo anche l’idea che la Federal Reserve potesse ottenere un atterraggio morbido.</p>
<p>Il mercato azionario americano è riuscito a mantenere il suo aumento settimanale solo di stretta misura, con l’indice del dollaro statunitense che registra la sua prima salita settimanale consecutiva in un mese e i rendimenti obbligazionari statunitensi che tornano al loro trend al rialzo. Sotto la pressione doppia dell’aumento del dollaro statunitense e dei rendimenti obbligazionari statunitensi, l’oro ha accelerato la sua discesa dai massimi storici. L’oro spot è sceso sotto la soglia dei $2.000 per la prima volta in due settimane, mentre i futures sull’oro sono scesi ai loro livelli più bassi in quasi due settimane, segnando il primo calo settimanale consecutivo in un mese.</p>
<p>Il petrolio greggio ha continuato a diminuire durante tutta la settimana, segnando il periodo di declino consecutivo più lungo degli ultimi cinque anni. Venerdì, i prezzi del petrolio hanno ripreso da un minimo di cinque mesi, attribuito a un annuncio congiunto del presidente russo Putin e del principe ereditario saudita Salman dopo il loro incontro, sottolineando l’importanza di una cooperazione continuata e la necessità che tutti i paesi dell’OPEC+ rispettino il protocollo. Ma ci sono ancora molti fattori negativi, tra cui un’imprevista impennata delle scorte di benzina negli Stati Uniti la scorsa settimana e una diminuzione del 9% delle importazioni di petrolio grezzo della Cina a novembre.</p>
<p>Guardando alla prossima settimana, la Federal Reserve, la Banca d’Inghilterra e la Banca Centrale Europea pubblicheranno le loro risoluzioni finali sui tassi di interesse per l’anno lo stesso giorno, con un peso innegabile. Oltre a queste tre principali banche centrali, secondo le statistiche, nei prossimi giorni, entro una finestra temporale di 60 ore, diverse economie che rappresentano il 60% dell’economia globale fisseranno i tassi di interesse, tra cui Svizzera, Norvegia, Brasile, Messico, Russia e altre. Prima e dopo il Super Thursday, il mercato riceverà anche dati pesanti come il rapporto CPI di novembre negli Stati Uniti, i “dati sul terrorismo” e il PMI del settore manifatturiero europeo e americano, aumentando la complessità del mercato.</p>
<p>Tra questi, il rapporto CPI degli Stati Uniti della prossima settimana e la decisione sui tassi d’interesse della Federal Reserve stabiliranno il tono per il mercato e l’economia per entrare nel 2024. Data l’intensità degli eventi di rischio, i trader affronteranno sfide significative.</p>
<p>In generale, le persone si aspettano che la Federal Reserve mantenga il suo tasso di interesse di riferimento al livello più alto degli ultimi 20 anni, poiché i decisori stanno valutando l’impatto ritardato di una serie di aumenti aggressivi dei tassi dal 2022 in poi.</p>
<p>Vale la pena notare che all’inizio di questa riunione, i funzionari della Federal Reserve hanno avuto accesso al nuovo rapporto sul CPI di novembre degli Stati Uniti pubblicato martedì prossimo. Ci si aspetta che il CPI core rafforzi la visione che l’inflazione si sta solo gradualmente indebolendo. Powell riconoscerà i progressi compiuti nell’inflazione e i rischi posti dalle persistenti pressioni sui prezzi in una conferenza stampa. Diversi economisti di Bloomberg hanno affermato che la Federal Reserve non avrà fretta di tagliare i tassi di interesse al fine di evitare ulteriori facilitazioni dell’ambiente finanziario.</p>
<p>Tuttavia, Nick Timiraos, un rinomato giornalista soprannominato “New Federal Reserve News Agency” e ora conosciuto come “Nikileaks” a Wall Street, ha pubblicato un importante articolo in un momento critico in cui la Federal Reserve si appresta a prendere la sua ultima decisione sui tassi di interesse questa settimana.</p>
<p>Nell’articolo ha concluso che è improbabile che i funzionari della Federal Reserve abbiano una discussione seria su quando tagliare i tassi di interesse questa settimana, e potrebbero non discuterne nei prossimi mesi a meno che la debolezza economica non superi le aspettative. Ha menzionato la storia del taglio dei tassi di interesse da parte della Federal Reserve circa sei mesi dopo l’ultimo rialzo dei tassi, nonché l’errore significativo della Federal Reserve di tagli prematuri dei tassi.</p>
<p>Tuttavia, le ultime previsioni sui tassi di interesse prevedono che la maggior parte degli ufficiali si aspetti un taglio dei tassi l’anno prossimo.</p>
<p>In realtà, il prossimo rialzo dei tassi di interesse della Federal Reserve non è più il nostro focus. Il nostro focus è sul taglio dei tassi di interesse dell’anno prossimo. Da ora in poi, il taglio dei tassi di interesse dell’anno prossimo è senza dubbio più di una o due volte.</p>
<p>Pertanto, da ora in poi, ci sono tre eventi principali per l’industria delle criptovalute l’anno prossimo. In primo luogo, il passaggio agevole degli ETF Bitcoin spot; In secondo luogo, l’aspettativa del taglio dei tassi d’interesse della Federal Reserve è saldamente stabilita; In terzo luogo, si avvicina il dimezzamento di Bitcoin.</p>
<p>La combinazione dei tre eventi sopra si trasformerà in un grande positivo, testimoniando l’arrivo di un mercato rialzista in questo ciclo insieme.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>