Tm90aXppZSBnaW9ybmFsaWVyZSB8IE11c2sgaGEgbWlyYXRvIGEgaW50ZWdyYXJlIGlsIG1vbmRvIGZpbmFuemlhcmlvIHJpbm9taW5hbmRvIFR3aXR0ZXIsIGlsIFJlZ25vIFVuaXRvIGhhIGluaXppYXRvIGEgZXNhbWluYXJlIFdvcmxkY29pbiwgaWwgcHJpbW8gbWluaXN0cm8gZ2lhcHBvbmVzZSBoYSBzb3N0ZW51dG8gV2ViMw==

2023-07-26, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/16903516110727.jpg" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Musk20ha20risposto20che20Twitter20ha20cambiato20nome20per20integrarsi20nel20mondo20finanziario20Il20Regno20Unito20ha20iniziato20a20esaminare20Worldcoin659484"><a name="Riassunto giornaliero delle criptovalute: Musk ha risposto che Twitter ha cambiato nome per integrarsi nel mondo finanziario; Il Regno Unito ha iniziato a esaminare Worldcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: Musk ha risposto che Twitter ha cambiato nome per integrarsi nel mondo finanziario; Il Regno Unito ha iniziato a esaminare Worldcoin</h2><p>Musk ha risposto al cambio di nome di Twitter scrivendo che Twitter è stato acquisito da X Corp non solo per garantire la libertà di parola ma anche per promuovere tutte le applicazioni di X. Questa non è solo una semplice rinominazione aziendale, ma (X Eco) sta facendo la stessa cosa.</p>
<p>Il nome di Twitter aveva un significato quando venivano scambiati frequentemente messaggi di soli 140 caratteri, come il cinguettio degli uccelli, ma ora puoi pubblicare praticamente qualsiasi cosa, incluso qualche ora di video.</p>
<p>Nei prossimi mesi, X aumenterà la sua capacità di comunicare e gestire in modo completo gli utenti in tutto il mondo finanziario. Il nome Twitter non ha alcun significato in questa situazione, quindi dobbiamo dirgli addio.</p>
<p>Il co-fondatore di OpenAI e fondatore di Worldcoin, Sam Altman, ha dichiarato sui social media che, come altri progetti ambiziosi, Worldcoin potrebbe avere successo o meno, ma provare cose del genere è un modo per progredire. Inoltre, Sam Altman ha dichiarato di pianificare di vedere una combinazione di Worldcoin e ChatGPT entro dieci anni.</p>
<p>Secondo Reuters, un portavoce dell’Ufficio del Commissario per le Informazioni, un’agenzia regolatoria dei dati nel Regno Unito, ha dichiarato di aver notato il lancio del progetto Worldcoin del co-fondatore di OpenAI, Sam Altman, nel Regno Unito e condurrà ulteriori indagini su di esso.</p>
<p>Nel frattempo, ZachXBT, il “detective on-chain”, ha messo in dubbio Worldcoin in un articolo sui social media, affermando che il team di progetto si è vantato dei numeri degli utenti, ma ha sfruttato le persone nei paesi in via di sviluppo. Inoltre, al momento Worldcoin sembra imporre solo l’autenticazione dell’autenticità degli utenti a livello di registrazione, creando un mercato nero per gli account, rispetto a una tariffa di soli $1 per account su Telegram.</p>
<p>Secondo Coindesk, WorldCoin ha aumentato la proporzione di token assegnati al personale interno e agli investitori dal 20% al 25%. Tuttavia, nei primi video del progetto, WorldCoin ha affermato che “WLD sarebbe migliore di BTC perché BTC è solo nelle mani di pochi ricchi.” ZachXBT ha detto che i problemi sopra citati lo hanno portato a opporsi al progetto Worldcoin, ma la narrazione di WLD potrebbe cambiare a seconda delle performance del token. Dopotutto, “aumento del prezzo = buon progetto, calo del prezzo = incubo distopico”.</p>
<p>Di recente, il primo ministro giapponese Fumio Kishida ha tenuto un discorso video al Tokyo International Forum sul “Next Stage of WebX Digital” organizzato da Coinpost, affermando che “Web3 fa parte di un nuovo tipo di capitalismo”.</p>
<p>Web3 può potenzialmente cambiare il quadro tradizionale di Internet e innescare un cambiamento sociale, e il governo sta lavorando per migliorare l’ambiente per promuovere Web3. Il primo ministro Kishida ha fortemente sperato che le principali imprese giapponesi potessero annunciare un progetto di grande scala per creare una zona economica preziosa nello spazio Metaverse al mondo in questa conferenza, e ha sperato che l’industria <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> riacquistasse attenzione e vitalità, e che nascessero nuovi progetti.</p>
<p>Con la popolarità dei bot Telegram, alcune piattaforme di dati di primo piano hanno iniziato a fare lo stesso, e Coinsecko ha recentemente aggiunto la sezione token Discord Bots. Si riporta che la sezione token Discord Bots abbia incluso cinque tipi di token: MEVFREE, COLLAB, TKB, ASAP e NOLO. La capitalizzazione di mercato di questa sezione è di $9.860.749, con un volume di trading delle ultime 24 ore di oltre $1 milione.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi933388"><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-BTC82283"><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/1690350270BTC.png" alt=""><br>Attualmente il mercato a breve termine è ancora indeciso nella sua direzione. C’è la possibilità di un ritracciamento nell’andamento complessivo al rialzo. Se si adotta una strategia rialzista, si dovrebbe prestare particolare attenzione alla linea viola che rappresenta l’andamento al rialzo. Una violazione di questa linea di tendenza potrebbe segnalare la fine del rimbalzo di quest’anno. Il prossimo livello di supporto è di $28,535 USD.</p>
<h3 id="h3-ETH925476"><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/1690350295ETH.png" alt=""><br>La tendenza a breve termine è nuovamente scesa al di sotto del livello di supporto di $1,857 USD. Una strategia ribassista dovrebbe aspettare un rimbalzo a $1,857 USD prima di considerare una posizione corta con un obiettivo di $1,755 USD. Se la struttura a medio e lungo termine non si stabilizza a $2,037 USD, la direzione complessiva rimane ribassista.</p>
<h3 id="h3-UNIBOT403045"><a name="UNIBOT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNIBOT</h3><p><img src="https://gimg2.gateimg.com/image/article/1690350314UNIBO.png" alt=""><br>Un chiaro modello di testa e spalle invertito è emerso sul grafico orario a breve termine, con un forte supporto a $ 103,03 USD. Si può considerare una posizione di breakout, con i prossimi obiettivi potenziali a $ 213,18 USD, $ 289,19 USD e $ 336,16 USD.</p>
<h2 id="h2-Macro20Concentrarsi20su20un20aumento20del20tasso20di20interesse20di202520punti20base20Il20disegno20di20legge20regolamentare20statunitense20per20le20criptovalute20sta20procedendo20senza20intoppi20il20che2020benefico20per20lo20sviluppo20sano20del20mercato20delle20criptovalute684676"><a name="Macro: Concentrarsi su un aumento del tasso di interesse di 25 punti base; Il disegno di legge regolamentare statunitense per le criptovalute sta procedendo senza intoppi, il che è benefico per lo sviluppo sano del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Concentrarsi su un aumento del tasso di interesse di 25 punti base; Il disegno di legge regolamentare statunitense per le criptovalute sta procedendo senza intoppi, il che è benefico per lo sviluppo sano del mercato delle criptovalute</h2><p>I dati economici degli Stati Uniti sono ancora pieni di contraddizioni. Da un lato, l’indice di fiducia dei consumatori è salito a un massimo di due anni. D’altra parte, l’attività manifatturiera della Federal Reserve di Richmond è continuata a essere debole a luglio e il sentiment del mercato è diventato sempre più teso. Nonostante le aspettative di un aumento dei tassi di interesse di 25 punti base questa settimana siano state digerite, qualsiasi indicazione successiva da parte di Powell accenderà il mercato.</p>
<p>L’indice del dollaro americano è sceso dopo 5 giorni di guadagni, chiudendo in calo dello 0,13% a 101,27. Il rendimento dei titoli di Stato americani è aumentato in tutto il mercato, e il rendimento a breve termine è continuato a salire più del rendimento a lungo termine. Il rendimento dei titoli di Stato americani a due anni è brevemente salito al 4,91% e ha chiuso vicino al 4,88%; Il rendimento dei titoli di Stato americani a dieci anni è brevemente salito al 3,92% nella giornata, chiudendo vicino al 3,88%.</p>
<p>Il prezzo dell’oro spot è salito alla vigilia della risoluzione di grande peso della Federal Reserve, recuperando quota 1.960 dollari e chiudendo in rialzo dello 0,51% a 1.964,74 dollari l’oncia. I tre principali indici azionari statunitensi hanno chiuso in rialzo, con l’indice Dow Jones in rialzo dello 0,08%, l’indice S&amp;P 500 in rialzo dello 0,29% e il Nasdaq in rialzo dello 0,61%.</p>
<p>Alle 19:00 (UTC) di mercoledì, la Federal Reserve sta per annunciare un aumento dei tassi di interesse di 25 punti base, che rientra nelle aspettative dell’intero mercato macroeconomico.</p>
<p>Tuttavia, il mercato ha anche aspettative per il discorso di Powell, e si ritiene ampiamente che il discorso di Powell possa diventare più falco, riportando il mercato alla calma e non a un livello caldo.</p>
<p>In breve, la risoluzione di aumento dei tassi di interesse alle 19:00 (UTC) e il discorso alle 19:30 (UTC) sono entrambi all’interno delle aspettative dei trader.</p>
<p>La Camera dei rappresentanti degli Stati Uniti e il Senato hanno raggiunto un protocollo bipartisan sul disegno di legge sulle criptovalute, che prevede di richiedere alle piattaforme di trading di criptovalute di registrarsi presso la Commodity Futures Trading Commission (CFTC) e di creare un nuovo quadro normativo per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’intero settore “alternativo” (non tradizionale).</p>
<p>Il protocollo è finalmente arrivato. Dal protocollo si può vedere che entrambe le parti riconoscono la piattaforma CFTC. In questo caso, crediamo che presto verranno emesse una serie di leggi regolamentari. Gli Stati Uniti devono recuperare sulle leggi regolamentari sulle criptovalute, e i paesi di tutto il mondo stanno emanando leggi regolamentari, come la Corea del Sud, il Giappone, e così via. Se aspettiamo che gli Stati Uniti promulghino una legge, crediamo che l’industria delle criptovalute sia un altro mondo e si sviluppi in modo più rapido.</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 re-post dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>