Tm90aXppZSBxdW90aWRpYW5lIHwgTWljcm9TdHJhdGVneSBhbm51bmNpYSBpIHJpc3VsdGF0aSBmaW5hbnppYXJpIG1vc3RyYW5kbyB1biBjb250aW51byBhdW1lbnRvIGRlbGxlIHJpc2VydmUgZGkgQml0Y29pbjsgOSBldmVudGkgcGnDuSBkZWduaSBkaSBub3RhIGRhIHRlbmVyZSBkJ29jY2hpbyBhIG5vdmVtYnJl

2023-11-02, 05:03

<p><img src="https://gimg2.gateimg.com/image/article/16989056391_2.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20MicroStrategy20continua20ad20aumentare20le20sue20posizioni20in20Bitcoin20gli20Stati20Uniti20regolamentano20completamente20lintelligenza20artificiale366133"><a name="Crypto Daily Digest: MicroStrategy continua ad aumentare le sue posizioni in Bitcoin, gli Stati Uniti regolamentano completamente l’intelligenza artificiale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: MicroStrategy continua ad aumentare le sue posizioni in Bitcoin, gli Stati Uniti regolamentano completamente l’intelligenza artificiale</h2><p>MicroStrategy ha annunciato i suoi risultati finanziari per il terzo trimestre del 2023 oggi. Il rapporto mostra che il fatturato totale di MicroStrategy nel terzo trimestre ha raggiunto i 129,5 milioni di dollari, con un aumento del 3% su base annua; Il fatturato delle licenze software è stato di 45 milioni di dollari, con un aumento del 16% su base annua; Il fatturato dei servizi di abbonamento è stato di 21 milioni di dollari, con un aumento del 28% su base annua.</p>
<p>La perdita operativa per il terzo trimestre è stata di $25,2 milioni, con una perdita netta di $143,4 milioni e una perdita diluita di $10,09 per azione. Dalla fine del secondo trimestre, MicroStrategy ha acquistato ulteriori 6067 Bitcoins per $167 milioni, o $27531 per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Secondo il rapporto finanziario odierno di MicroStrategy, al 31 ottobre 2023, MicroStrategy detiene un totale di 158.400 Bitcoin, con un costo totale di 4,69 miliardi di dollari e un prezzo medio di possesso di 29.586 dollari. Sulla base del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> di $35488 al momento della pubblicazione, le posizioni di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di MicroStrategy sono aumentate a $934 milioni.</p>
<p>Secondo The Block, il totale degli sbloccaggi dei token a novembre è stato di 450 milioni di dollari, con <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Valanga</a> e ci si aspetta che Hashflow subisca sblocchi significativi, sbloccando oltre 320 milioni di token.</p>
<p>Tra questi, <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> sbloccherà 24,8 milioni di token APT il 12 novembre, corrispondenti al 10% della loro fornitura circolante e del valore approssimativo di $172,9 milioni. La maggior parte dei fondi sbloccati (circa $82,7 milioni) <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> ai contributori principali, con 58,6 milioni di dollari che vanno agli investitori, 22,3 milioni di dollari che vanno alla comunità e 9,3 milioni di dollari che vanno alla Fondazione Aptos.</p>
<p>Secondo i dati di Rootdate, ci sono stati un totale di 75 transazioni di finanziamento nel campo della criptovaluta nell’ottobre 2023, con un importo totale di finanziamento di circa 426 milioni di dollari, che rappresenta l’importo di finanziamento più basso degli ultimi quattro anni e una diminuzione anno su anno del 63%. A ottobre dell’anno scorso, c’erano un totale di 135 transazioni di finanziamento nel campo della criptovaluta, con un importo totale di finanziamento di circa 1.157 miliardi di dollari.</p>
<p>Il 30 ottobre, il presidente americano Biden ha firmato un nuovo decreto che mira a ridurre i rischi posti dall’intelligenza artificiale (IA) per i consumatori, i lavoratori, le minoranze e la sicurezza nazionale. Questo ordine amministrativo richiede agli sviluppatori di sistemi di intelligenza artificiale che rappresentano un rischio per la sicurezza nazionale, l’economia, la salute pubblica o la sicurezza degli Stati Uniti di condividere i risultati dei test di sicurezza con il governo americano in conformità con il Defense Production Act prima di rilasciare i prodotti al pubblico.</p>
<p>“Questo è spaventoso per l’innovazione negli Stati Uniti,” ha detto Jeff Amico, ex partner di a16z e attuale responsabile delle operazioni presso Gensyn Network. Ha dichiarato che i requisiti di segnalazione dell’ordine “sono essenzialmente relazioni delle aziende pubbliche per le startup che costruiscono modelli di grandi dimensioni.” Amico ha sottolineato che quando si ottiene una grande quantità di potenza di calcolo, l’ordine richiede la divulgazione di informazioni, Questo “considera il calcolo - una tecnologia essenzialmente neutra - come una risorsa pericolosa che deve essere regolamentata.”</p>
<p>In seguito a questa notizia, i token legati all’intelligenza artificiale sono crollati in tutto il complesso. Secondo i dati di CoinGecko, GRT è sceso del 2,4% in 24 ore, FET è sceso del 2,2% in 24 ore, AGIX è sceso del 6,1% in 24 ore e OCEAN è sceso del 2,8% in 24 ore.</p>
<p>Successivamente, diamo un’occhiata agli eventi principali degni di nota di novembre:</p>
<p>1/Il 6 novembre, OpenAI ha convocato la sua conferenza;</p>
<p>2/9 novembre è la data del briefing della SEC su <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>;</p>
<p>Il 3 novembre è stata effettuata la terza revisione degli ETF spot Bitcoin di 21 Shares/ARK Invest; Vediamo cosa farà la SEC allora;</p>
<p>Il 12 novembre, è previsto che Aptos (APT) sblocchi 24,84 milioni di token, equivalenti al 10,06% della sua circolazione e del valore approssimativo di $167 milioni;</p>
<p>5/Il 14 novembre sono stati pubblicati i dati sull’IPC di ottobre degli Stati Uniti;</p>
<p>Il 17 novembre, sono stati esaminati per la prima volta gli ETF Hashdex e Franklin Bitcoin spot;</p>
<p>Il 21 novembre, l’ETF Bitcoin spot Global X Bitcoin è stato sottoposto alla seconda revisione; 7/</p>
<p>Il 24 novembre, <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX) prevede di sbloccare 9,54 milioni di token, pari al 2,69% del flusso di traffico e del valore approssimativo di $105 milioni;</p>
<p>Il 30 novembre, Blur potrebbe lanciare la seconda stagione di airdrop.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi221382"><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-BTC729477"><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/1698905755BTC.png" alt=""><br>Nel breve termine, il prezzo continua a oscillare intorno ai 36.000 dollari, e se rompe questo livello, il prossimo obiettivo è 37.755 dollari. Come previsto, ieri c’è stata una leggera correzione dei prezzi, con un’ascesa iniziale seguita da un ribasso e poi da una rottura. Per la strategia a breve termine, è cruciale osservare il livello di 35.165 dollari e, se tiene, è probabile che continui un trend rialzista.</p>
<h3 id="h3-ETH173154"><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/1698905776ETH.png" alt=""><br>A breve termine, ETH sta testando il livello di resistenza di $1.857. Una strategia conservativa è quella di aspettare una rottura al di sopra di $1.857 e poi puntare a $1.951. D’altra parte, se scende al di sotto di $1.754, il prossimo supporto è a $1.726. È importante notare che il volume di trading a breve termine sta diminuendo, senza notizie positive significative.</p>
<h3 id="h3-TIA201203"><a name="TIA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TIA</h3><p><img src="https://gimg2.gateimg.com/image/article/1698905792TIA.png" alt=""><br>TIA ha raggiunto un massimo storico di $2,999 dall’apertura e si è chiusa a $2,125, seguendo una struttura di Fibonacci. Nel breve termine, potrebbe continuare a testare il livello di $3, e una strategia più conservativa sarebbe aspettare una rottura sopra i $3 e puntare a $3,35, $3,54 e $4,42.</p>
<h2 id="h2-Macro20La20Federal20Reserve20mantiene20i20tassi20di20interesse20invariati20Powell20ha20dichiarato20di20non20aver20affatto20considerato20di20abbassare20i20tassi746476"><a name="Macro: La Federal Reserve mantiene i tassi di interesse invariati, Powell ha dichiarato di non aver affatto considerato di abbassare i tassi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La Federal Reserve mantiene i tassi di interesse invariati, Powell ha dichiarato di non aver affatto considerato di abbassare i tassi</h2><p>Alle 2:00 del mattino, ora di Pechino, la Federal Reserve ha annunciato che i tassi di interesse (5,25% - 5,50%) rimarranno invariati. Questa riunione è la meno informativa da quando la Federal Reserve ha avviato il ciclo di aumento dei tassi di interesse nel marzo dell’anno scorso.</p>
<p>Capisci rapidamente cosa ha detto Powell, e non ci sono evidenti momenti salienti in tutto l’articolo:</p>
<p>1 / La Federal Reserve prenderà decisioni in ogni riunione, ma non ha ancora preso una decisione su quale azione intraprendere alla prossima riunione (come dichiarato nella riunione precedente, la porta al rialzo dei tassi di interesse non è stata completamente chiusa);</p>
<p>2/Un arresto del governo è una potenziale fonte di rischio (il mercato è attualmente concentrato solo sul presente e potrebbe non comprendere ancora questa affermazione, ma fate attenzione al rischio di un arresto del governo degli Stati Uniti a novembre);</p>
<p>3/La Federal Reserve è preoccupata per quanto tempo le politiche devono rimanere restrittive (Powell non ha fornito una risposta su quanto tempo i tassi di interesse elevati devono essere mantenuti);</p>
<p>4/Dato le misure adottate finora, la Federal Reserve continuerà ad agire con cautela (l’aspettativa di agire con cautela in realtà implica che la possibilità di non aumentare i tassi di interesse in futuro è maggiore rispetto ad aumentarli);</p>
<p>5/Non ho considerato o discusso tagli dei tassi di interesse (molti cadono nella trappola di scommettere sulla riduzione dei tassi di interesse in futuro);</p>
<p>6/Se la situazione finanziaria continua a stringere, potrebbe influenzare le azioni della Federal Reserve, ma resta da vedere se la situazione sarà la stessa (non c’è una risposta positiva alla visione dell’incremento dei rendimenti dei bond statunitensi);</p>
<p>Pertanto, la dichiarazione della Federal Reserve al FOMC ha ribadito che valuterà l’entità di ulteriori politiche di inasprimento. L’attività economica si è espansa a un “ritmo sostenuto” nel terzo trimestre. L’inflazione rimane elevata e il comitato per la definizione delle politiche è fermamente impegnato a riportare il tasso di inflazione all’obiettivo del 2%. Se ci sono rischi che possono influenzare il raggiungimento degli obiettivi, sii pronto ad adeguare la posizione politica “in modo appropriato”.</p>
<p>Il presidente della Federal Reserve Powell ha dichiarato di essere ancora concentrato su una missione duale e di essere saldamente impegnato nell’obiettivo di ripristinare l’inflazione al 2%. Senza stabilità dei prezzi, l’economia non può funzionare. L’impatto completo della politica di restrizione monetaria non è ancora stato avvertito e, considerando i progressi compiuti, il Comitato per la politica monetaria procederà con cautela. Siamo preoccupati se si debbano effettuare ulteriori aumenti dei tassi di interesse, se la politica sia sufficientemente restrittiva.</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 ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>