Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgRGlwYXJ0aW1lbnRvIGRpIEdpdXN0aXppYSBkZWdsaSBTdGF0aSBVbml0aSByaXNwb25kZSBhbGwnaW5jaWRlbnRlIGRpIENaOyBsYSBtb2RhbGl0w6AgQmxhc3Qgw6ggc3RhdGEgbWVzc2EgaW4gZGlzY3Vzc2lvbmUgZGFsbGUgaXN0aXR1emlvbmkgVkM7IERZRFgsIDFJTkNIIGUgYWx0cmkgdG9

2023-11-27, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17010667511_27.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20Dipartimento20di20Giustizia20degli20Stati20Uniti20risponde20allincidente20di20CZ20Il20modello20Blast2020stato20messo20in20discussione20dalle20istituzioni20VC669555"><a name="Crypto Daily Digest: Il Dipartimento di Giustizia degli Stati Uniti risponde all’incidente di CZ; Il modello Blast è stato messo in discussione dalle istituzioni VC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il Dipartimento di Giustizia degli Stati Uniti risponde all’incidente di CZ; Il modello Blast è stato messo in discussione dalle istituzioni VC</h2><p>Innanzitutto, teniamo d’occhio l’evolversi dell’incidente CZ. Il 26 novembre, il Dipartimento di Giustizia degli Stati Uniti ha risposto alla dichiarazione della squadra di difesa di CZ negli ultimi documenti giudiziari, affermando che affrontano una condanna “breve” e non hanno motivazione per fuggire. Il governo ha chiaramente affermato che secondo le linee guida penali, CZ può essere condannato a un massimo di 18 mesi di prigione e i pubblici ministeri possono richiedere una condanna statutaria massima di 10 anni.</p>
<p>Il documento menziona che, sebbene CZ abbia connessioni familiari e non sia stato imprigionato, la punizione che affronta avrà un impatto significativo su di lui. Sulla base di ciò, il governo degli Stati Uniti ritiene che le misure proposte per limitare i viaggi di CZ durante la confessione e la condanna siano ragionevoli e necessarie, al fine di garantire che CZ possa assumersi la responsabilità legale negli Stati Uniti e ridurre il suo potenziale rischio di fuga.</p>
<p>L’indirizzo del contratto Layer 2 Network Blast lanciato da Pacman, il fondatore di BLUR, la piattaforma NFT più popolare di recente, attualmente detiene un valore totale degli asset di oltre $500 milioni.</p>
<p>Tra di essi, ETH per un valore di 439 milioni di dollari è stato depositato nel protocollo Lido, e 61,81 milioni di dollari sono stati depositati nel protocollo Maker. E con questo tipo di dati, questo modello e le crescenti voci interrogative nella comunità attuale, è evidente che i progetti con modelli CX rappresentano significativi rischi sconosciuti fino a quando non vengono effettivamente implementati. Anche Paradigm, una nota società di venture capital che ha investito in Blast, non può stare con le mani in mano.</p>
<p>Dan Robinson, Partner e Direttore della Ricerca di Paradigm, ha recentemente dichiarato sui social media che Paradigm non è d’accordo con la decisione di Blast di attivare il suo ponte prima della rete Layer 2 e vietare i prelievi per tre mesi, e ritiene che ciò abbia portato cattivi presagi ad altri progetti e che la maggior parte delle attività di vendita ridurrà l’efficienza dei team seri.</p>
<p>Robinson ha dichiarato che Paradigm ha espresso le loro preoccupazioni al team di Blast, ma “ci sono ancora molti punti di disaccordo”, ma Paradigm assumerà seriamente la sua responsabilità nell’ecosistema.</p>
<p>L’account X del fondatore di un altro popolare progetto SocialFi, Friend.tech, non può essere visualizzato. Secondo l’analisi della comunità, l’account X @0xRacerAlt del fondatore di Friend.tech, Racer, è sospettato di essere stato cancellato e attualmente viene mostrato come “non esistente”. Secondo i dati di DefiLlama, il TVL di Friend.tech è sceso a 33,2 milioni di dollari, una diminuzione di oltre il 36% rispetto al suo massimo storico di 52,04 milioni di dollari il 2 ottobre.</p>
<p>Secondo le notizie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, dopo essere volato a oltre $18 per transazione due volte la scorsa settimana, il costo delle transazioni di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è diminuito. Al 24 novembre, il costo medio per transazione è di circa $5.89, e il costo mediano per trasferimento è di $2.86. A ottobre, i minatori hanno ricevuto $885 milioni in ricompense e spese.</p>
<p>Al 25 novembre 2023, i minatori hanno guadagnato un totale di 945 milioni di dollari, inclusi i costi delle transazioni e i sussidi. Alle 4:00 PM ora orientale di sabato, escludendo i sussidi, i minatori hanno accumulato 124,98 milioni di dollari solo dalle spese. Questo numero si avvicina al record di ricavi delle commissioni di transazione del 2023 di 125,92 milioni di dollari stabilito a maggio.</p>
<p>Secondo i dati di Token Unlocks, questa settimana 9 progetti subiranno lo sblocco dei token, con un valore totale superiore a $600 milioni. Tra di essi:</p>
<p>Dydx (DYDX) sbloccherà circa 152 milioni di token del valore approssimativo di $520 milioni nei prossimi sette giorni, corrispondenti all’84,41% dell’offerta circolante;</p>
<p>Sui (SUI) sbloccherà circa 82,42 milioni di token del valore approssimativo di circa 52,34 milioni di dollari nei prossimi sette giorni, corrispondenti all’8,54% dell’offerta circolante;</p>
<p>Alle 16:00 (UTC) del 30 novembre, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> (OP) sbloccherà circa 24,16 milioni di token del valore di circa 43,73 milioni di dollari, corrispondenti al 2,74% dell’offerta circolante;</p>
<p>Alle 12:00 (UTC) del 1° dicembre, <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> (1INCH) sbloccherà approssimativamente 98,74 milioni di token del valore approssimativo di 35,03 milioni di dollari, corrispondenti al 9,48% dell’offerta circolante;</p>
<p>Alle 14:00 (UTC) del 27 novembre, Yield Guild Games (YGG) sbloccherà circa 16,69 milioni di token del valore approssimativo di 6,27 milioni di dollari, corrispondenti al 5,48% dell’offerta circolante;</p>
<p>Alle 0:00 del 29 novembre (UTC), Nym (NYM) sbloccherà circa 25 milioni di token del valore approssimativo di $3.91 milioni, pari al 4.1% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 28 novembre, SingularityNET (AGIC) sbloccherà circa 9,39 milioni di token del valore approssimativo di 2,9 milioni di dollari, corrispondenti al 0,76% dell’offerta circolante;</p>
<p>Alle 7:00 (UTC) del 1 dicembre, Acala (ACA) sbloccherà circa 27,43 milioni di token del valore approssimativo di $1,62 milioni, pari al 3,31% della fornitura circolante;</p>
<p>Alle 12:00 (UTC) del 3 dicembre, Tornado Cash ( <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> sbloccherà approssimativamente 175.000 token del valore approssimativo di $665.000, corrispondenti al 4,62% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi547302"><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-BTC548855"><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/1701066789BTC.png" alt=""><br>La tendenza settimanale continua con sei settimane consecutive di guadagni, mostrando segni di un potenziale rallentamento. All’interno del modello triangolo convergente, sono delineati due possibili scenari: un’uscita al di sopra di $37.980 con obiettivi a $40.500 e $42.015, o un movimento ribassista che rompe l’andamento al rialzo, con cautela attorno al livello di $40.000 per evitare di perturbare la struttura del mercato.</p>
<h3 id="h3-ETH981123"><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/1701066809ETH.png" alt=""><br>Il grafico a 4 ore rompe al di sopra di un significativo trend al ribasso, formando un pattern di fondo a breve termine. Se le strutture ribassiste si mantengono, è possibile un retest di $1.857. Le posizioni ribassiste aggressive dovrebbero essere caute vicino alla resistenza. Gli osservatori del trend rialzista attendono una rottura della resistenza, puntando a $2.135, con un potenziale target a $2.381.</p>
<h3 id="h3-KP3R683516"><a name="KP3R" class="reference-link"></a><span class="header-link octicon octicon-link"></span>KP3R</h3><p><img src="https://gimg2.gateimg.com/image/article/1701066828KP3.png" alt=""><br>Il protocollo KP3R, leader nel settore DeFi, è sceso del 96,45% rispetto al suo massimo storico di $2.065, con un livello di supporto significativo a $40,05. La partenza del fondatore del progetto si allinea con i segnali di mercato di un potenziale cambio di rotta. Questa settimana si prevede un ulteriore ritracciamento a $64,05 e $52,98, con una strategia a lungo termine mirata a tornare ai massimi precedenti.</p>
<h2 id="h2-Macro20Le20aspettative20di20tagli20dei20tassi20di20interesse20potrebbero20ulteriormente20aumentare20i20prezzi20delloro20attenzione20ai20dati20PCE20core20di20questo20gioved947055"><a name="Macro: Le aspettative di tagli dei tassi di interesse potrebbero ulteriormente aumentare i prezzi dell’oro; attenzione ai dati PCE core di questo giovedì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le aspettative di tagli dei tassi di interesse potrebbero ulteriormente aumentare i prezzi dell’oro; attenzione ai dati PCE core di questo giovedì</h2><p>Durante la settimana di trading abbreviata a causa delle festività del Ringraziamento negli Stati Uniti, gli investitori rimangono ottimisti sul fatto che la Federal Reserve non alzerà ulteriormente i tassi di interesse e potrebbe iniziare a tagliarli nella prima metà del 2024.</p>
<p>Con l’ampliamento della larghezza di mercato, tutti e tre i principali indici azionari statunitensi sono saliti per la quarta settimana consecutiva e si prevede che otterranno la loro migliore performance mensile da oltre un anno. L’oro ha chiuso sopra la critica soglia di $2.000, segnando la seconda settimana consecutiva di guadagni.</p>
<p>D’altra parte, a causa del rilascio di alcuni ostaggi nella Striscia di Gaza che ha ridotto il premio di rischio geopolitico, i prezzi del petrolio sono scesi venerdì. Tuttavia, poiché l’incontro dell’OPEC+ ha deciso il protocollo di riduzione della produzione del 2024, i prezzi del petrolio hanno comunque registrato il loro primo aumento settimanale in oltre un mese.</p>
<p>Nella prossima settimana, con l’imminente rapporto chiave sull’inflazione degli Stati Uniti e la riunione dell’OPEC+, ci si aspetta che la volatilità del mercato si intensifichi nuovamente la prossima settimana.</p>
<p>I discorsi finali di diversi funzionari della Federal Reserve, tra cui Powell, prima del periodo di silenzio diventeranno il centro dell’attenzione del mercato. I più recenti verbali della riunione della Federal Reserve mostrano che i responsabili politici ritengono collettivamente che mantenere i tassi di interesse immutati sia appropriato, confermando la loro prudenza e disponibilità a stringere ulteriormente le politiche in caso di imprevista inflazione al rialzo.</p>
<p>La risposta del mercato a questo è stata deludente, quasi certo che la Federal Reserve abbia concluso il suo ciclo di rialzo dei tassi di interesse, ma i funzionari non sono disposti a dichiararlo esplicitamente prima di essere sicuri che l’inflazione non si riprenderà. I contratti di swap legati al periodo di riunione della Federal Reserve continuano a indicare che la possibilità di ulteriori rialzi dei tassi di interesse da parte della Federal Reserve è vicina allo zero. Secondo lo strumento FedWatch del Chicago Mercantile Exchange, la probabilità che la Federal Reserve tagli i tassi di interesse prima di maggio dell’anno prossimo è leggermente aumentata, passando da circa il 57% prima della pubblicazione dei verbali della riunione al circa il 64%.</p>
<p>Phillip Streible, Chief Market Strategist di Blue Line Futures, ha affermato che a causa dei dati deboli pubblicati questa settimana, ciò dovrebbe spingere la Federal Reserve verso una posizione più accomodante, portando a un deterioramento delle prestazioni dell’indice del dollaro americano e potenzialmente diventando un fattore positivo per i prezzi dell’oro. La banca commerciale tedesca ha scritto in un rapporto che l’aumento dei prezzi dell’oro è dovuto alle speranze che la Federal Reserve non aumenti ulteriormente i tassi di interesse, poiché gli ultimi dati economici sono piuttosto deludenti. Nel frattempo, la banca ritiene che il potenziale al rialzo attuale dell’oro sembri limitato, poiché i suoi economisti prevedono che il primo taglio dei tassi di interesse sarà attuato a metà dell’anno prossimo, il che significa che solo allora l’oro potrà continuare a rimanere sopra i $2.000.</p>
<p>La prossima settimana potrebbero esserci buone e cattive notizie per i dati economici degli Stati Uniti. Il mercato immobiliare diventerà il focus all’inizio della settimana. Mercoledì si prevede che il tasso di crescita annuale del PIL per il terzo trimestre aumenterà leggermente dal 4,9% al 5,0%. La forte crescita dell’economia statunitense nel terzo trimestre non è sorprendente, poiché le vendite al dettaglio sono state forti, i tassi di disoccupazione erano bassi e la crescita dei salari è stata forte durante questo periodo. Non ci si aspetta che la seconda correzione di questi dati scateni una forte reazione sul mercato. Si prevede che l’indice ISM PMI manifatturiero di novembre, pubblicato venerdì, aumenterà leggermente, ma rimarrà comunque all’interno della zona di contrazione.</p>
<p>Il vero punto forte è un insieme di dati di giovedì, tra cui l’indice dei prezzi del nucleo PCE e il reddito personale e la spesa. I dati PCE sono un indicatore di inflazione favorito dalla Federal Reserve, che aiuterà a spiegare l’estensione del processo anti-inflazione e a convalidare la fissazione dei tassi di interesse nel mercato. Si prevede che il tasso di crescita annuale complessivo del PCE negli Stati Uniti a ottobre rallenterà dal 3,4% al 3,1%, mentre si prevede che il PCE principale rallenti dal 3,7% al 3,5%.</p>
<p>Da un punto di vista mese per mese, ci si aspetta che i tassi di crescita complessiva e di base del PCE siano rispettivamente dello 0,1% e dello 0,2%. Qualsiasi ulteriore raffreddamento della pressione dei prezzi renderà sempre più difficile per la Federal Reserve controllare le aspettative di mercato per i tagli ai tassi di interesse. Inoltre, si prevede che reddito personale e spese rallentino in ottobre, con una crescita mese su mese di soli dello 0,2%, indicando che i consumatori stanno stringendo la cinghia all’inizio del nuovo trimestre dopo aver speso molto in estate.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore 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 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>