Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgcHJlc2lkZW50ZSBkZWxsYSBTRUMgaGEgYWZmZXJtYXRvIGNoZSBCVEMgbm9uIMOoIHVuYSBzaWN1cmV6emEsIFRlbGVncmFtIGNvbGxhYm9yYSBjb24gVGVuY2VudCBwZXIgY3JlYXJlIHVuYSAicGlhdHRhZm9ybWEgZGkgZWNvc2lzdGVtYSBzdXBlcg==

2023-09-28, 04:38

<p><img src="https://gimg2.gateimg.com/image/article/16958815720928.jpg" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Il20presidente20della20SEC20ha20dichiarato20che20il20BTC20non2020un20titolo20la20perdita20di20fondi20rubati20nel20terzo20trimestre20ha20superato20la20somma20di20quella20nella20prima20met20del202023691295"><a name="Riepilogo giornaliero delle criptovalute: Il presidente della SEC ha dichiarato che il BTC non è un titolo, la perdita di fondi rubati nel terzo trimestre ha superato la somma di quella nella prima metà del 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: Il presidente della SEC ha dichiarato che il BTC non è un titolo, la perdita di fondi rubati nel terzo trimestre ha superato la somma di quella nella prima metà del 2023</h2><p>Durante un’audizione tenuta dalla Commissione per i servizi finanziari della Camera dei rappresentanti degli Stati Uniti, Patrick McHenry, Presidente della Commissione per i servizi finanziari della Camera dei rappresentanti degli Stati Uniti, ha chiesto a Gary Gensler, Presidente della SEC, “Ti ho fatto una domanda su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> all’ultima riunione. Oggi vorrei fare una domanda su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Perché non ritieni che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sia un titolo? Pensi che Bitcoin sia un titolo?</p>
<p>Gensler ha risposto: “Non penso che il Bitcoin sia un titolo perché non supera il test di Howey”. Gensler ha anche affermato: “Ci sono molti truffatori e ladri nell’industria delle criptovalute. Questo danneggia gli interessi degli investitori.”</p>
<p>Gensler ha anche affermato che i token cripto non diventeranno valuta nel breve termine.</p>
<p>Secondo Eric Balchunas, analista senior di ETF presso Bloomberg, la SEC spera di accelerare il lancio degli ETF futures su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (poiché sperano di liberarli dal loro lavoro dopo la chiusura del governo), quindi richiedono agli aspiranti di aggiornare i loro documenti entro venerdì pomeriggio (questo non è un compito facile, deve essere svolto entro 48 ore, specialmente per gli emittenti indipendenti), in modo da poter lavorare lunedì e scambiare martedì.</p>
<p>L’agenzia di sicurezza blockchain Beosin, in collaborazione con SUSS NiFT e Footprint Analytics, ha pubblicato un rapporto globale sulla sicurezza <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> per il Q3 2023, affermando che la perdita totale nel settore Web3 nel Q3 è stata di $889,26 milioni a causa di attacchi hacker, truffe di phishing e incidenti di Rug Pull. L’importo della perdita nel Q3 ha superato l’importo totale della perdita nella prima metà del 2023 (approssimativamente $330 milioni nel Q1 e $333 milioni nel Q2, rispettivamente).</p>
<p>Un totale di 43 incidenti principali di sicurezza si sono verificati questo trimestre, con perdite per 5401,6 milioni di dollari. Tra questi, 29 casi si sono verificati nel campo DeFi, rappresentando circa il 67,4%, e il tipo di progetto con la perdita più elevata è stata la catena pubblica. Questi 29 attacchi DeFi hanno causato una perdita totale di 98,23 milioni di dollari, classificandosi al secondo posto tra tutti i tipi di progetto.</p>
<p>Diviso per tipo di attacco: 9 incidenti di perdita di chiave privata hanno causato una perdita di $223 milioni; L’incidente di sicurezza di Mixin Network ha comportato una perdita di $200 milioni; 22 falle contrattuali hanno comportato una perdita di circa $93.27 milioni.</p>
<p>Dal punto di vista del capitale <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a>, ci sono ancora 360 milioni di dollari (67%) presso gli indirizzi degli hacker. Solo il 10% dei fondi rubati è stato recuperato in questo trimestre. La rete Ethereum e Mixin insieme rappresentano il 79% della perdita totale.</p>
<p>Secondo TechCrunch, l’applicazione di messaggistica Telegram e TON Foundation stanno collaborando con Tencent per trasformare Telegram in una “super piattaforma di ecosistema di applicazioni” simile a WeChat, consentendo a sviluppatori e commercianti di terze parti di sviluppare piccoli programmi e interagire con gli utenti, dai giochi ai ristoranti. Gli sviluppatori possono utilizzare Java per creare interfacce infinitamente flessibili che possono essere avviate all’interno di Telegram o sostituire completamente qualsiasi sito web.</p>
<p>Influenzato da questa notizia, TON ha brevemente superato i 2,1 USDT, classificandosi al 12° posto per valore di mercato, con un prezzo attuale di 2,17 USDT e un aumento del 2,6% nelle ultime 24 ore.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi833507"><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-BTC988797"><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/1695881612BTC.png" alt=""><br>Come previsto, ieri è emerso un modello di inversione al ribasso e il volume di trading a breve termine è gradualmente aumentato verso una linea di tendenza ribassista principale. Le fluttuazioni a breve termine sono probabili che continueranno intorno al livello di $26.510 e si prevede che persistano fino alla fine del mese prima di un movimento significativo in ottobre. La strategia a medio termine mostra una continua debolezza nel volume di trading.</p>
<h3 id="h3-TRB319980"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1695881639TRB.png" alt=""><br>Nel corso dell’ultimo mese, TRB è salito da un minimo di $9.47 per testare il livello di resistenza di $46.93. Stamattina ha continuato a salire, raggiungendo il nostro obiettivo iniziale di $65.23. Nel breve termine, è possibile un ritracciamento a $52.95, mentre l’outlook a lungo termine dovrebbe mantenere il trend al rialzo e il livello di $46.93.</p>
<h3 id="h3-MKR913477"><a name="MKR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MKR</h3><p><img src="https://gimg2.gateimg.com/image/article/1695881660MKR.png" alt=""><br>Una struttura a lungo termine sta mostrando un grande pattern testa e spalle rialzista, rompendo la tendenza al ribasso complessiva all’inizio di questo mese e raggiungendo il perfetto target di resistenza allo 0,786 a $1.541. Si prevede un ritracciamento nell’intervallo di $1.422-$1.452. La prospettiva a lungo termine rimane positiva, con target a $1.588, $1.723, $1.832, $1.941 e $2.094.</p>
<h2 id="h2-Macro20Se20la20politica20della20Fed20porta20a20un20atterraggio20morbido20laspettativa20di20tagli20dei20tassi20di20interesse20spinger20il20mercato20a20riprendersi20rapidamente477294"><a name="Macro: Se la politica della Fed porta a un atterraggio morbido, l’aspettativa di tagli dei tassi di interesse spingerà il mercato a riprendersi rapidamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Se la politica della Fed porta a un atterraggio morbido, l’aspettativa di tagli dei tassi di interesse spingerà il mercato a riprendersi rapidamente</h2><p>Mercoledì, l’indice del dollaro statunitense ha raggiunto un nuovo massimo di 10 mesi poiché l’economia statunitense ha mostrato più slancio rispetto ad altri paesi, chiudendo infine in rialzo dello 0,49% a 106,71. Il rendimento dei titoli di stato decennali statunitensi è salito rapidamente nella sessione statunitense, raggiungendo un nuovo massimo in 16 anni e chiudendo al 4,613%, aumentando l’acquisto di dollari statunitensi. Le valute non statunitensi sono sotto pressione collettiva, con l’euro che scende sotto l’1,05 rispetto al dollaro statunitense per la prima volta da gennaio. Lo yen giapponese è sceso fino al 0,5% rispetto al dollaro statunitense a 149,77, il suo livello più basso dallo scorso ottobre.</p>
<p>L’oro spot è sceso per il terzo giorno di contrattazione consecutivo, rompendo al di sotto di $1.880 all’oncia durante la sessione, segnando la prima volta da marzo 13. Ha toccato un minimo di $1.872,59 all’oncia, scendendo di più di $30 dal suo massimo giornaliero, e chiudendo infine in ribasso dell’1,33% a $1.875,12 all’oncia. L’argento spot ha fluttuato e è sceso, chiudendo infine in ribasso dell’1,38% a $22,55 all’oncia.</p>
<p>Concentrati sull’annuncio di stasera alle 12:30 (UTC) dei valori finali del tasso trimestrale annualizzato del PIL reale degli Stati Uniti, del tasso trimestrale della spesa per consumi personali reale e del tasso trimestrale annualizzato dell’indice dei prezzi del PCE di base, nonché sul numero di domande iniziali di sussidi di disoccupazione negli Stati Uniti per la settimana che termina il 23 settembre.</p>
<p>Alle 13:00 (UTC), il Comitato per il voto FOMC 2023 e il presidente della Fed di Chicago Gullsby hanno tenuto un discorso. La mattina successiva alle 1:00, la governatrice della Federal Reserve Lisa Cook ha tenuto un discorso. Alle 4:00 del mattino del giorno successivo, il presidente della Federal Reserve Powell parteciperà a una conferenza sull’industria dell’istruzione e risponderà alle domande del pubblico presente e dei partecipanti online.</p>
<p>Recentemente, AJ Oden, stratega globale degli investimenti presso JPMorgan Wealth Management, ha dichiarato che l’indice S&amp;P 500 raggiungerà un record l’anno prossimo poiché la Federal Reserve probabilmente non aumenterà più i tassi di interesse.</p>
<p>Secondo la sua dichiarazione, gli strateghi della banca si aspettano che l’indice S&amp;P 500 raggiunga un nuovo massimo entro la metà del 2024. Ciò significa che è necessario un aumento di almeno il 12% rispetto al livello attuale per superare il record storico stabilito nel gennaio 2022.</p>
<p>Questo è principalmente perché JPMorgan Chase si aspetta che la Federal Reserve termini l’aumento dei tassi di interesse e presto si sposti verso tagli dei tassi, che costituiranno il principale fattore rialzista per il mercato azionario.</p>
<p>Oden ha fatto notare che dopo che i governatori delle banche centrali hanno aumentato significativamente i tassi di interesse nel corso dell’ultimo anno per ridurre l’inflazione, gli ufficiali della Federal Reserve stanno ora mostrando un atteggiamento più ottimista nei confronti dell’economia.</p>
<p>In un’intervista con CNBC martedì, Oden ha dichiarato che il sommario delle previsioni economiche più recenti della Federal Reserve (SEP) mostra che l’indicatore di inflazione preferito dalla Fed, l’inflazione delle spese per consumi personali (PCE), dovrebbe scendere al 2% entro il 2026.</p>
<p>Ha detto: “Se guardiamo all’ultimo meeting della Federal Reserve della settimana scorsa e all’SEP, un atterraggio morbido sembra molto importante per i responsabili delle politiche. L’SEP descrive effettivamente uno scenario ‘ragazza bionda’.</p>
<p>Secondo lo strumento CME FedWatch, il mercato si aspetta una probabilità del 44% che i tassi di interesse scendano al di sotto dei livelli attuali entro giugno 2024. Più avanti, per quanto riguarda le previsioni di mercato azionario, Oden ha aggiunto: ‘A un certo punto, la Federal Reserve si girerà e da quel momento in poi il mercato si riprenderà’.</p>
<p>Oden ha dichiarato che il rimbalzo delle azioni statunitensi innescato dai futuri tagli dei tassi di interesse beneficerà anche della forte spesa dei consumatori statunitensi. Nonostante una significativa restrizione delle condizioni finanziarie nell’ultimo anno, la spesa dei consumatori rimane resiliente. Ha sottolineato che l’88% delle azioni di beni di consumo non essenziali nell’indice S&amp;P 500 sono “previste di avere un buon rendimento”.</p>
<p>Queste opinioni non sono coerenti con i previsionisti di mercato azionario più pessimisti. Hanno affermato che a causa della possibilità di un rimbalzo dell’inflazione e della Federal Reserve che mantiene i tassi di interesse a livelli restrittivi, una recessione economica è imminente.</p>
<p>Dato che il presidente della Federal Reserve Powell ha avvertito nella riunione di settembre della politica della Fed che i tassi di interesse potrebbero rimanere alti per un periodo prolungato, i rendimenti dei titoli sono aumentati vertiginosamente e il mercato azionario ha subito una vendita sostenuta.</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 riutilizzo dell'articolo a condizione che Gate.io venga menzionato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>