Tm90aXppZSBnaW9ybmFsaWVyZSB8IFNpIHByZXZlZGUgY2hlIGxhIGNvbmRhbm5hIGRpIFNCRiBub24gc2lhIGluZmVyaW9yZSBhIDQwIGFubmk7IE11c2sgaGEgcGlhbmlmaWNhdG8gZGkgdHJhc2Zvcm1hcmUgbGEgcGlhdHRhZm9ybWEgWCBpbiB1bmEgYmFuY2EgZGlnaXRhbGUgbCdhbm5vIHByb3NzaW1v

2023-10-30, 04:10

<p><img src="https://gimg2.gateimg.com/image/article/16986456531030.jpg" alt=""></p>
<h2 id="h2-Riassunto20quotidiano20delle20criptovalute20si20prevede20che20la20sentenza20di20SBF20sia20di20almeno204020anni20Musk20pianifica20di20trasformare20la20piattaforma20X20in20un20sito20di20incontri20e20una20banca20digitale20lanno20prossimo32678"><a name="Riassunto quotidiano delle criptovalute: si prevede che la sentenza di SBF sia di almeno 40 anni; Musk pianifica di trasformare la piattaforma X in un sito di incontri e una banca digitale l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto quotidiano delle criptovalute: si prevede che la sentenza di SBF sia di almeno 40 anni; Musk pianifica di trasformare la piattaforma X in un sito di incontri e una banca digitale l’anno prossimo</h2><p>Secondo la testimonianza di SBF di ieri, alcuni professionisti legali hanno aumentato le loro aspettative minime per la condanna. I professionisti legali si aspettano che la sentenza di SBF sia di almeno 40 anni.</p>
<p>Secondo Business Insider, citando fonti interne, Musk insiste sul fatto che la piattaforma X diventerà un sito di incontri ‘maturo’ e una banca digitale entro il 2024. Musk non ha fornito dettagli su come X sia diventata un’applicazione di incontri o se gli utenti avevano richieste per tali funzionalità, ma questa idea è in linea con la filosofia di Musk di promuovere funzionalità a pagamento.</p>
<p>Secondo i dati di DeFiLlama, i criminali informatici hanno rubato circa 1 miliardo di dollari dal mercato delle criptovalute fino ad oggi nel 2023, una diminuzione del 60% anno su anno. La quantità più alta di furto nell’industria delle criptovalute quest’anno è avvenuta a settembre, quando gli hacker hanno rubato 308,23 milioni di dollari. A luglio, i criminali informatici hanno perso 238,42 milioni di dollari attraverso molteplici attacchi di hacking di criptovalute e a marzo hanno perso 213,58 milioni di dollari. Nonostante il valore dei fondi rubati sia diminuito, nel 2023 sono stati registrati più incidenti di hacking di criptovalute rispetto al 2022.</p>
<p>Il 30 ottobre, secondo i dati di mercato, c’è stato un trend generale al rialzo nei token del settore dei giochi (P2E), con SLP (valuta di gioco all’interno di Axie) che è salito del 31,48% in 24 ore e attualmente viene quotato a $0.0025. <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a> (Gala) è aumentato del 18,6% in 24 ore ed è attualmente quotato a $0,021. AXS (Axis Infinity) è aumentato del 15,77% in 24 ore ed è attualmente quotato a $ 5,8. GMT ( <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cdai</a>) è aumentato del 13,1% nelle ultime 24 ore ed è attualmente quotato a $0,19. SAND ( <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cdai</a>) è aumentato del 10,96% in 24 ore e ora è quotato a $0,36. MANA ( <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a> È salito del 10,45% in 24 ore e ora è quotato a $0,38.</p>
<p>Secondo i dati di The Block, la media mobile a 7 giorni del volume degli scambi spot su piattaforme ben note sul mercato ha superato i 24 miliardi di dollari il 26 ottobre, raggiungendo il suo livello più alto da fine marzo. Inoltre, rispetto all’estate, il mercato ha sperimentato una volatilità più significativa poiché i trader stanno gestendo titoli riguardanti il possibile lancio di spot. <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a> Gli ETF, che i sostenitori credono creeranno nuovi canali per gli afflussi di capitale. I dati mostrano che la volatilità di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è salita ai livelli più alti da aprile.</p>
<p>Il 30 ottobre, secondo un rapporto di DeSpread Research, i coreani sono attivi trader di criptovalute con una forte preferenza per le Altcoin e i token locali, e le piattaforme di trading locali superano anche i concorrenti globali in termini di volume di trading. Secondo un sondaggio condotto dall’Unità di Intelligence Finanziaria sudcoreana (KoFIU), il numero di investitori di criptovalute nel paese ha raggiunto circa 6 milioni quest’anno, pari al 10% della popolazione totale. La maggior parte di questi investitori si concentra principalmente su attività di investimento incentrate su piattaforme di trading centralizzate, rendendo significativa l’influenza delle piattaforme di trading centralizzate nel mercato delle criptovalute coreano.</p>
<p>DeSpread ha scritto nel rapporto: “Le piattaforme di trading sudcoreane hanno reagito in modo esplosivo alle notizie correlate a Ripple. Il volume di trading delle quattro principali piattaforme di trading in Corea del Sud è aumentato da $27 miliardi a giugno a $37 miliardi a luglio, un aumento del 37% rispetto al mese precedente; La maggior parte degli investitori individuali su Upbit mostra un forte interesse per le Altcoin con un alto potenziale di profitto e tende ad accettare i rischi associati. Questo è considerato uno dei motivi dell’alta proporzione di transazioni di Altcoin nel mercato coreano.” La rete di trading preferita in Corea del Sud è anche diversa, poiché la rete di <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> è utilizzata per la maggior parte delle transazioni a causa dei costi di trading relativamente bassi.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi607449"><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-BTC826743"><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/1698645686BTC.png" alt=""><br>I guadagni a breve termine di $36.000 in BTC sembrano soddisfacenti, indicando una fase di massimi a breve termine. Si consiglia cautela contro la possibilità di una rapida caduta a $33.000, creando un potenziale inversione del punto più alto. Si consiglia di mantenere saldamente i livelli di supporto di $32.500 e $30.800.</p>
<h3 id="h3-ETH88141"><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/1698645707ETH.png" alt=""><br>ETH ha raggiunto un massimo di $ 1.857 questo mese, formando un pattern “M” ribassista in un momento critico. Si suggerisce di mantenersi stabile a 1.754$ e, in caso di violazione, aspettarsi ulteriori cali a 1.726$ e 1.694$. Nel complesso, si prevede una continua diminuzione del volume degli scambi.</p>
<h3 id="h3-MC746006"><a name="MC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MC</h3><p><img src="https://gimg2.gateimg.com/image/article/1698645723MC.png" alt=""><br>MC ha accumulato un volume di trading significativo dal suo minimo di $0.2934 dello scorso mese, salendo lentamente fino a un recente massimo di $0.5700. Nel breve termine, ci si aspetta un secondo movimento verso l’alto, ma se non supererà i $0.57, potrebbe trattarsi di un rimbalzo temporaneo. Tenete d’occhio un imminente evento di “sostituzione del token”.</p>
<h2 id="h2-Macro20Concentrati20sulla20decisione20sui20tassi20di20interesse20della20Fed20di20gioved20e20si20prevede20che20il20mercato20continui20a20mantenere20tassi20di20interesse20stabili611303"><a name="Macro: Concentrati sulla decisione sui tassi di interesse della Fed di giovedì e si prevede che il mercato continui a mantenere tassi di interesse stabili" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Concentrati sulla decisione sui tassi di interesse della Fed di giovedì e si prevede che il mercato continui a mantenere tassi di interesse stabili</h2><p>Il momento più importante di questa settimana è giovedì. Alle 2 del mattino di giovedì, la Federal Reserve ha annunciato la sua decisione di aumentare i tassi di interesse. Successivamente, alle 18:30 (UTC) di mercoledì, il presidente della Federal Reserve, Powell, ha tenuto una conferenza stampa sulla politica monetaria.</p>
<p>La scorsa settimana, l’indice dei prezzi PCE core negli Stati Uniti ha registrato un tasso annuale del 3,7% a settembre, stabilendo un nuovo minimo da maggio 2021. L’indicatore PCE rafforza la ragione per cui la Federal Reserve rimarrà in silenzio. Pertanto, la Nuova Agenzia di Notizie della Federal Reserve ritiene che la Federal Reserve continuerà a sospendere i rialzi dei tassi d’interesse.</p>
<p>Nel frattempo, il mercato ritiene generalmente che la Federal Reserve manterrà invariato il tasso di interesse del 5,5%. Se fosse così, sarebbe anche la prima volta, da quando è iniziato questo ciclo di aumenti dei tassi di interesse, che ci sono due mesi consecutivi senza aumenti dei tassi di interesse.</p>
<p>Il 3 novembre alle 20:30 ora di Pechino, gli Stati Uniti pubblicheranno il loro rapporto sull’occupazione non agricola. Il mercato ritiene che la conclusione delle politiche di stretta della Federal Reserve dipenda dal fatto che il mercato del lavoro e la crescita dei salari siano sufficienti per alleviare le pressioni inflazionistiche.</p>
<p>In termini del conflitto israelo-palestinese, Israele ha iniziato a entrare nella zona della Striscia di Gaza per la guerra di strada, il che significa che il conflitto israelo-palestinese continua ad escalare senza alcuna possibilità di cambiamento. Ma il mercato del Medio Oriente, che ha aperto domenica, non ha mostrato quasi segni di panico.</p>
<p>Alle 14:00 di Tel Aviv, l’indice azionario israeliano TA-35 è salito dell’1,1%, riducendo il calo dal momento dell’infiltrazione di Hamas il 7 ottobre all’11%. Da un punto di vista storico, con il trasferimento dei rischi geopolitici, le fluttuazioni di mercato che ne conseguono sono spesso di breve durata. Ma se altri paesi sono coinvolti in questo conflitto, l’incertezza che ne deriva si intensificherà.</p>
<p>Se la situazione si aggrava ulteriormente è una preoccupazione per gli operatori. Il Presidente iraniano ha avvertito che le azioni di Israele hanno superato la linea rossa e potrebbero costringere tutti a prendere provvedimenti; l’Arabia Saudita e gli Emirati Arabi Uniti condannano l’escalation della situazione; Gli Stati Uniti affermano che il rischio di conseguenze regionali della guerra rimane alto.</p>
<p><a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cdai</a> <a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a> Autore:<br><strong>Byron B.</strong>, Ricercatore di Gate.io<br><a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cdai</a> Traduttore: Joy Z.<br><a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br><a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove comprare cdai</a></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, saranno intraprese azioni legali per violazione del copyright.<br><a href="/how-to-buy/cdai-cdai" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cdai</a> <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a></p>