Tm90aXppZSBxdW90aWRpYW5lIHwgVHdpdHRlciBoYSBzdmVsYXRvIHVuIG51b3ZvIGxvZ28gWCwgV29ybGRjb2luIGhhIHVmZmljaWFsbWVudGUgbGFuY2lhdG8gaSB0b2tlbiBXTEQsIEJsb29tYmVyZyBwcmV2ZWRlIGNoZSBsYSBGZWQgc29zcGVuZGEgbCdhdW1lbnRvIGRlaSB0YXNzaSBkaSBpbnRlcmVzc2UgZG9wbyBsdWdsaW8=

2023-07-25, 04:14

<p><img src="https://gimg2.gateimg.com/image/article/16902640730725.jpg" alt=""></p>
<h2 id="h2-Riassunto20quotidiano20delle20criptovalute20Twitter20dice20addio20allera20del20Blue20Bird20Worldcoin20lancia20ufficialmente20i20token20WLD20e20le20posizioni20degli20HODLers20di20BTC20raggiungono20un20nuovo20massimo20storico769473"><a name="Riassunto quotidiano delle criptovalute: Twitter dice addio all’era del “Blue Bird”, Worldcoin lancia ufficialmente i token WLD e le posizioni degli HODLers di BTC raggiungono un nuovo massimo storico." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto quotidiano delle criptovalute: Twitter dice addio all’era del “Blue Bird”, Worldcoin lancia ufficialmente i token WLD e le posizioni degli HODLers di BTC raggiungono un nuovo massimo storico.</h2><p>Secondo la pagina dell’account ufficiale di Twitter, l’account ha cambiato il suo avatar nel logo X, e l’ID dell’account è stato impostato su ‘X’. Musk ha dichiarato che il marchio Twitter dirà gradualmente addio all’immagine del ‘Blue Bird’ e la sostituirà con il logo X.</p>
<p>Musk ha cambiato il profilo del suo account personale Twitter con il logo “X”. Musk ha twittato il 22 luglio che X.com è collegato a Twitter e che oggi verrà lanciato un logo temporaneo X.</p>
<p>Con Elon Musk che ha annunciato ieri piani per rinnovare e sostituire l’iconico logo Blue Bird di Twitter con il logo X, diversi token contrassegnati con la lettera “X” sono stati lanciati durante la notte e hanno visto una crescita anomala.</p>
<p>Dopo il tweet di Musk, alcuni sviluppatori speculativi hanno emesso nuovi token nel fine settimana, con un token chiamato “AI-X” (con lo stesso logo dell’azienda spaziale SpaceX di Musk) che è aumentato di dieci volte, e l’altro token chiamato “Deus X” che è salito del 2600%.</p>
<p>I commercianti professionisti hanno dichiarato che questo <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> esiste perché le valute principali come BTC ed ETH stanno vivendo una bassa volatilità, costringendo alcuni partecipanti al mercato a scommettere su meme coin e criptovalute con bassa capitalizzazione di mercato.</p>
<p>Ieri, Worldcoin ha ufficialmente annunciato il lancio dei token WLD, che verranno distribuiti a oltre 2 milioni di persone in tutto il mondo. Nella dichiarazione, Worldcoin ha promesso di accelerare la registrazione distribuendo Orbs in oltre 35 città in 20 paesi in tutto il mondo.</p>
<p>Gli individui che superano la verifica di Orb riceveranno inizialmente 25 token WLD e futuri contributi regolari. Si prevede che l’economia esatta del token del progetto venga annunciata più tardi lunedì. A causa dell’incertezza normativa, WLD non potrà essere utilizzato negli Stati Uniti.</p>
<p>Secondo i dati della pagina World App, la fase Genesis Grant è stata aperta per la richiesta, con un periodo di apertura dal 24 luglio al 31 luglio. Gli utenti iris non verificati possono ancora richiedere in anticipo 25 WLD, che verranno conservati per 365 giorni. Gli utenti che hanno richiesto in anticipo possono trasferire i loro token WLD dopo aver completato la verifica dell’iris. Al momento della pubblicazione, 3703 utenti hanno completato la richiesta anticipata, con un massimo di 1 milione di utenti che possono richiedere; 3405 utenti hanno completato la richiesta.</p>
<p>Si riferisce che il progetto è uno dei progetti più controversi nel campo della criptovaluta. Il suo obiettivo è aiutare le persone a verificare personalmente le loro credenziali attraverso la scansione dell’iride per dimostrare la propria identità online. Più di 2 milioni di persone (la maggior parte delle quali proviene dai paesi dell’emisfero meridionale) hanno superato la verifica e oggi riceveranno tutti la loro giusta quota di token WLD.</p>
<p>Secondo l’economia dei token rilasciata da Worldcoin, il 75% è allocato alle comunità, il 9,8% ai team, il 13,5% agli investitori TFH e l’1,7% alle riserve TFH. La circolazione iniziale era di 143 milioni, di cui 100 milioni sono stati concessi in prestito ai market maker, e più di 43 milioni di token WLD sono stati allocati prima del rilascio. L’inflazione è del 1,5% all’anno e si prevede che inizierà tra 15 anni.</p>
<p>Il rapporto settimanale dei dati di Glassnode mostra che i detentori a lungo termine di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> ovvero gli indirizzi del portafoglio che detengono <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> da almeno 155 giorni) controllano ora tre quarti dell’offerta di circolazione di Bitcoin, con un record di possesso.</p>
<p>I dati di Glassnode mostrano che il saldo in questi portafogli è aumentato di 62.882 BTC ($1,83 miliardi) questo mese, raggiungendo un record di 14,52 milioni di BTC, superando il picco di 14,48 milioni di BTC del 21 maggio. Questo nuovo record significa che tali detentori possiedono il 75% dell’attuale fornitura di 19,437 milioni di Bitcoin.</p>
<p>Glassnode ha twittato, “indica che tra gli investitori esperti, HODLing è la dinamica di mercato preferita.” Entità con liquidità insufficiente o partecipanti online con quasi nessuna storia di spesa controllano il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> tasso di fondi nei portafogli, il che indica che l’accumulazione degli utenti nel mercato continua e la pressione dei venditori continua a indebolirsi. Questo mese, il numero di Bitcoin detenuti da queste entità illiquide è aumentato di oltre 90.000.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi470360"><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-BTC499106"><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/1690264117BTC.png" alt=""><br>Nel breve termine, il prezzo è sceso sotto i 29,5 mila dollari USA con un volume di scambi aumentato. Il prossimo supporto da tenere d’occhio è a 28.535 dollari USA, e c’è la possibilità di un ritracciamento nell’ampio trend al rialzo. Per la strategia rialzista, è consigliabile monitorare la trendline viola; una rottura al di sotto potrebbe segnalare la fine del trend di ripresa di quest’anno. Il livello di supporto chiave da mantenere è di 28.535 dollari USA.</p>
<h3 id="h3-ETH976218"><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/1690264140ETH.png" alt=""><br>Nel breve termine, il trend ha rotto al di sotto del primo supporto della struttura ascendente e ieri ha visto un significativo calo del volume al di sotto del supporto di $1.857 USD. La strategia ribassista suggerisce di attendere un rimbalzo a $1.857 USD per avviare una posizione corta mirando a $1.755 USD. Il trend a breve termine è orientato al ribasso.</p>
<h3 id="h3-UNIBOT509104"><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/1690264158UNIBOT.png" alt=""><br>Nel breve termine, potrebbe continuare a diminuire insieme al mercato più ampio. Presta particolare attenzione al forte supporto a $103.03 USD. Se c’è un movimento verso l’alto sostenuto, i prossimi obiettivi sono $213.18 USD, $289.19 USD e $336.16 USD in sequenza.</p>
<h2 id="h2-Macro20Bloomberg20guarda20avanti20alla20decisione20settimanale20dei20tassi20di20interesse20della20Fed20e20prevede20una20pausa20a20lungo20termine20nelle20rialzi20dei20tassi20di20interesse20dopo20luglio21355"><a name="Macro: Bloomberg guarda avanti alla decisione settimanale dei tassi di interesse della Fed e prevede una pausa a lungo termine nelle rialzi dei tassi di interesse dopo luglio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bloomberg guarda avanti alla decisione settimanale dei tassi di interesse della Fed e prevede una pausa a lungo termine nelle rialzi dei tassi di interesse dopo luglio</h2><p>Bloomberg ha scritto un articolo che guarda con interesse all’incontro della Federal Reserve FOMC di questa settimana, affermando che la Federal Reserve si appresta ad aumentare i tassi di interesse di 25 punti base nel suo incontro di luglio.</p>
<p>Dalla riunione di metà giugno, i dati economici misti potrebbero non aver placato il dibattito interno all’interno della Federal Reserve su se l’aumento dei tassi di luglio dovrebbe essere l’ultimo.</p>
<p>Pertanto, il discorso di Powell nella conferenza stampa potrebbe soddisfare sia i colombi che i falchi.</p>
<p>Egli potrebbe sottolineare che le prospettive economiche sono diventate più luminose e che il processo di declino dell’inflazione sta avanzando ulteriormente, il che significa che il percorso verso un “atterraggio morbido” è stato ampliato.</p>
<p>Tenendo conto dell’incertezza della politica monetaria in ritardo, potrebbe suggerire che la Federal Reserve adotti un atteggiamento di attesa alla prossima riunione, mentre avverte che alcuni membri del FOMC si aspettano ancora un altro rialzo dei tassi quest’anno.</p>
<p>Lo scenario di riferimento di Bloomberg prevede che la Federal Reserve mantenga la stabilità dei tassi di interesse dopo averli aumentati a luglio, per poi iniziare a tagliare i tassi di interesse dal secondo trimestre del 2024.</p>
<p>Tuttavia, ci sono ancora alcuni potenziali shock negativi dell’offerta che potrebbero invertire il processo inflazionistico, spingendo infine la Federal Reserve a riprendere i rialzi dei tassi di interesse entro la fine del 2024. I principali rischi includono scioperi diffusi e shock dei prezzi globali dei prodotti alimentari causati da fattori meteorologici. ‘Attualmente, descriviamo la traiettoria dei tassi di interesse come una ‘pausa prolungata nei rialzi dei tassi’ dopo luglio, con pochissima possibilità che la Federal Reserve riprenda i rialzi dei tassi dopo.’</p>
<p>In una parola, dato che i recenti dati economici aumentano la possibilità di un atterraggio morbido, è improbabile che il FOMC prenda misure significative per cambiare la situazione. Powell adotterà un atteggiamento di attesa, lasciando intendere che salterà l’aumento dei tassi di interesse nella riunione di settembre - crediamo che questo ‘salto’ diventerà un’azione prolungata.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno prese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>