RGFpbHkgTmV3cyB8IFNmZXJhIHN2aWx1cHBhdG9yZSBibG9ja2NoYWluIGxhbmNpYXRvIFRHIEV4dGVuc2lvbiBkYSBCYW5rIHRvIFdhbGxldDsgTGEgQ29tbWlzc2lvbmUgZXVyb3BlYSBzb2xsZWNpdGEgcHJlcGFyYXRpdmkgcGVyIGwnaW50ZWdyYXppb25lIGRpIEJsb2NrY2hhaW4gZSBBSQ==

2024-05-28, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/17168681681_18.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20cripto20lo20sviluppatore20blockchain20Sphere20ha20lanciato20lestensione20Telegram20dalla20banca20al20portafoglio20La20Commissione20europea20sollecita20la20preparazione20per20lintegrazione20di20blockchain20e20intelligenza20artificiale20Ethereum20Layer20220Taiko2020attivo20sul20mainnet735797"><a name="Riassunto giornaliero di cripto: lo sviluppatore blockchain Sphere ha lanciato l’estensione Telegram dalla banca al portafoglio; La Commissione europea sollecita la preparazione per l’integrazione di blockchain e intelligenza artificiale; Ethereum Layer 2 Taiko è attivo sul mainnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di cripto: lo sviluppatore blockchain Sphere ha lanciato l’estensione Telegram dalla banca al portafoglio; La Commissione europea sollecita la preparazione per l’integrazione di blockchain e intelligenza artificiale; <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer 2 Taiko è attivo sul mainnet</h2><p><strong>Lo sviluppatore di blockchain Sphere ha lanciato l’estensione Telegram dalla banca al portafoglio</strong><br>Lo sviluppatore di blockchain Sphere ha lanciato un’estensione di Telegram da banca a portafoglio. Questo sviluppatore, che si concentra sulla fornitura di servizi di stablecoin per le imprese, ha annunciato che lancerà un nuovo percorso per il deposito e il prelievo di valuta fiat all’interno di Telegram.</p>
<p>L’estensione permetterà agli utenti di Telegram di trasferire direttamente fondi bancari nei loro portafogli all’interno dell’applicazione e viceversa. Il costo pubblicitario per transazione per gli utenti iniziali è dello 0,1%. Il servizio sarà aperto agli utenti iniziali il 27 maggio e si prevede di lanciarlo completamente più avanti quest’anno.</p>
<p>Anche se gli utenti provenienti da paesi non soggetti a sanzioni possono utilizzare l’estensione di Telegram, devono associare il servizio a conti bancari denominati in dollari statunitensi o euro. Questa mossa continua a rendere Telegram un centro di innovazione e sviluppo crypto, e crea un potente ecosistema blockchain su Telegram con un gran numero di robot e applicazioni, come i robot Unibet e CoinGecko.</p>
<p>Telegram Open Network (TON) ha attirato molti investitori, speculatori e appassionati di criptovalute. Secondo i dati di DemandSage, Telegram conta 800 milioni di utenti attivi ogni mese e oltre 52 milioni di persone utilizzano la piattaforma quotidianamente. Il volume di download di questa applicazione ha superato 1 miliardo di volte e si prevede che entro la fine del 2024 il numero di utenti di Telegram raggiungerà 1 miliardo.</p>
<p>Inoltre, l’India ha il maggior numero di utenti di Telegram, con un numero stimato di 104 milioni di utenti, rendendo la piattaforma un terreno fertile per fornire servizi fintech ai paesi in via di sviluppo. Espandere i servizi finanziari ai paesi in via di sviluppo rimane un focus centrale dell’industria blockchain. Sviluppatori come Ripple Labs e Standard Diamond Co. stanno cercando di creare soluzioni innovative per le persone del 21° secolo che non dispongono di servizi finanziari sufficienti.</p>
<p><strong>La Commissione europea sollecita preparativi per l’integrazione di blockchain e intelligenza artificiale</strong><br>L’Osservatorio e Forum europeo della blockchain (EUBOF) raccomanda che l’UE si prepari all’integrazione della tecnologia blockchain e dell’intelligenza artificiale (AI). L’iniziativa ha monitorato e analizzato lo sviluppo della blockchain in diverse regioni dell’Europa e ha pubblicato una relazione conclusiva.</p>
<p>La relazione sottolinea il potenziale di combinare la blockchain con altre tecnologie per guidare l’innovazione. L’EUBOF ha identificato forti tendenze legate all’integrazione continua di blockchain e intelligenza artificiale. Secondo le nuove normative, le entità custodiali possono ricevere fino al 50% dei costi di approvvigionamento e operativi dei supercomputer di intelligenza artificiale dall’Unione Europea. La proprietà di queste macchine può essere trasferita all’entità custodiale cinque anni dopo i test di accettazione.</p>
<p><strong>Ethereum Layer 2 Taiko va live sul mainnet</strong><br>Il riepilogo di Taiko basato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è stato lanciato sulla mainnet. Taiko utilizza una prova di rollup che si basa sul validatore dei blocchi Ethereum per ordinare le transazioni. Taiko prevede di lanciare DAO entro la fine dell’anno, trasferendo gradualmente il controllo del protocollo alla sua comunità.</p>
<p>Il co-fondatore di Ethereum, Vitalik Buterin, ha proposto il primo blocco sulla rete principale di Taiko, il cui metadato include i nomi di ogni contributore principale di Taiko.</p>
<p>Il token Taiko dovrebbe essere lanciato alcune settimane dopo l’entrata in funzione della mainnet. Inoltre, Taiko prevede di lanciare un programma di incentivi chiamato Trailblazers, che attira la partecipazione della comunità ricompensandola per il completamento di compiti e l’interazione con Internet.</p>
<p>Il progetto ha recentemente annunciato airdrop ai membri della comunità prima del lancio della mainnet. Il progetto prevede di distribuire il 5% della sua offerta di token di 1 miliardo ai membri della comunità, noti come “Genesis airdrop”.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20guida20il20mercato20in20generale20e20finalmente2020arrivata20la20stagione20delle20Altcoin384600"><a name="Tendenze di mercato: BTC guida il mercato in generale, e finalmente è arrivata la stagione delle Altcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC guida il mercato in generale, e finalmente è arrivata la stagione delle Altcoin</h2><p>Nella tendenza del mercato odierno, il rimbalzo del prezzo di BTC ed ETH ha spinto l’intero mercato al rialzo, aumentando di solito la fiducia del mercato e attirando maggiori flussi di capitale. Il mantenuto afflusso netto di ETF spot BTC indica un crescente interesse e partecipazione degli investitori istituzionali in criptovalute, il che rappresenta un segnale positivo per il mercato. Tuttavia, la diminuzione della predominanza di BTC potrebbe indicare che i fondi stanno fluendo verso altre altcoin, dando il via alla cosiddetta “Altseason”.</p>
<p>Guadagni macroeconomici nel mercato azionario statunitense: La continua crescita e i massimi storici del mercato azionario statunitense riflettono le aspettative ottimistiche per le prospettive economiche, il che aiuta ad aumentare l’attrattiva degli asset rischiosi, inclusi i criptovalute. La diminuzione dell’indice del dollaro statunitense potrebbe essere un fattore trainante per la crescita del mercato delle criptovalute.</p>
<h3 id="h3-Punti20Caldi20del20Mercato327789"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p><strong>NON è aumentato di oltre il 40%</strong><br>Sfondo: NOT è un token di gioco per l’ecosistema Ton. Ton è un ecosistema di gioco basato su blockchain. L’aumento di NOT potrebbe essere guidato dallo sviluppo di questo ecosistema.</p>
<p>Impatto: Anche altri token di gioco come HIGH DAR, ENJ e altri hanno seguito l’aumento, dimostrando l’interesse e l’entusiasmo del mercato per i giochi blockchain.</p>
<p><strong>concetto di meme</strong><br>Sfondo: FLOKI MOG, PENG, TURBO, WOJAK, MAGA, SAMO, MEW e altri token Meme hanno registrato un forte aumento, in particolare TURBO e MAGA, che sono aumentati rispettivamente di più di 20 volte e 10 volte in una sola settimana.</p>
<p>Rischio: L’aumento dei token Meme spesso comporta un alto rischio e volatilità, e gli investitori devono essere vigili riguardo ai rapidi cambiamenti nel sentiment di mercato e ai potenziali rischi di ritracciamento.</p>
<p><strong>ZEUS è salito di oltre il 25% in un solo giorno</strong><br>Sfondo: Zeus Network è un protocollo che consente la comunicazione cross-chain sul <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain e il primo progetto Launchpad nella storia di Jupiter. Lo sviluppo di questa tecnologia innovativa e dell’ecosistema potrebbe essere un fattore trainante per il suo aumento di prezzo.</p>
<p>Impatto: Come il primo protocollo sulla catena <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> a introdurre <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> con la liquidità in Solana, il successo di ZEUS potrebbe aprire la strada a ulteriori progetti cross-chain in futuro.</p>
<p>L’attuale tendenza generale al rialzo del mercato e la diversificazione dei punti caldi riflettono l’attività e lo sviluppo diversificato del mercato delle criptovalute. Gli investitori devono essere cauti mentre godono dei benefici portati dall’aumento del mercato, soprattutto per quanto riguarda i Meme token volatili e i progetti emergenti, la gestione del rischio è particolarmente importante. Nel contesto della volatilità di mercato e dei frequenti argomenti caldi, gli investimenti diversificati possono ridurre efficacemente il rischio di un singolo asset. Scegliere progetti con scenari di applicazione pratica e innovazione tecnologica per gli investimenti, evitando la ricerca cieca di alti rendimenti.</p>
<h2 id="h2-Macro20Il20mercato20statunitense20riapre20mentre20il20mercato20asiatico20fluttua20I20prezzi20delloro20e20del20petrolio20greggio20sono20leggermente20aumentati131585"><a name="Macro: Il mercato statunitense riapre, mentre il mercato asiatico fluttua; I prezzi dell’oro e del petrolio greggio sono leggermente aumentati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato statunitense riapre, mentre il mercato asiatico fluttua; I prezzi dell’oro e del petrolio greggio sono leggermente aumentati</h2><p>Il mercato statunitense è stato chiuso lunedì 27 maggio e non è stato rilasciato alcun report sul mercato globale durante quel periodo.</p>
<p>Martedì 28 maggio, dopo aver registrato un aumento nella giornata di negoziazione precedente, i mercati azionari asiatici hanno mostrato un andamento altalenante. Funzionari della Banca centrale europea hanno dichiarato che, in quanto l’inflazione rallenta, c’è spazio per la BCE per abbassare i tassi di interesse, aumentando le aspettative per un taglio dei tassi il 6 giugno. Questa notizia ha rafforzato l’appetito per il rischio degli investitori, anche se il mercato rimane volatile prima della pubblicazione di alcuni importanti dati sull’inflazione.</p>
<p>L’indice azionario MSCI Asia Pacific è salito dello 0,4%, con l’indice Hang Seng di Hong Kong in aumento dello 0,7% e l’indice Nikkei del Giappone in calo dello 0,3%, invertendo i guadagni della giornata di trading precedente. Le azioni blue chip cinesi hanno beneficiato dell’impegno ulteriore di Pechino a investire nell’industria dei semiconduttori, con le azioni tecnologiche in aumento dell’1% ieri e in lieve calo oggi.</p>
<p>Il mercato azionario europeo ha chiuso leggermente più alto lunedì, con i rendimenti dei titoli di Stato in calo poiché la Banca centrale europea (BCE) ha accennato a imminenti tagli dei tassi di interesse, ma l’attività di trading è stata ridotta a causa della chiusura di alcuni importanti mercati globali.</p>
<p>Il Pan European STOXX 600 ha chiuso in rialzo dello 0,3%, avvicinandosi ad un massimo storico registrato all’inizio di questo mese. I principali decision maker della Banca Centrale Europea hanno dichiarato che poiché l’inflazione rallenta, c’è spazio per la banca centrale per abbassare i tassi di interesse, ma deve prendere tempo per rilassare le politiche, anche se la direzione politica è chiara.</p>
<p>Il focus di questa settimana è sull’indice dei prezzi al consumo di maggio della zona euro, che verrà pubblicato venerdì, mentre i dati sull’inflazione individuale per Germania, Spagna e Francia verranno anche pubblicati questa settimana. Secondo i dati della Borsa di Londra, la Banca Centrale Europea sembra essere pronta a ridurre i tassi di interesse al prossimo incontro della prossima settimana, con scommesse che indicano una possibilità di oltre il 90%.</p>
<p>I dati sull’inflazione negli Stati Uniti saranno anche pubblicati venerdì, il che potrebbe aiutare i trader a valutare il momento e la frequenza dei potenziali tagli dei tassi di interesse della Federal Reserve quest’anno.</p>
<p>I futures azionari di Wall Street hanno registrato una forte performance prima della riapertura dopo la chiusura del mercato statunitense. I futures dell’indice S&amp;P 500 sono aumentati dello 0,1%, mentre i futures dell’indice Nasdaq sono saliti dello 0,2%. Un importante evento di rischio si verificherà questo venerdì, momento in cui il tono del trading sarà determinato dai dati sui consumi personali di base (PCE) degli Stati Uniti e dai dati sull’inflazione dell’Eurozona.</p>
<p>Nel mercato valutario, il dollaro statunitense è sceso per il terzo giorno di contrattazioni consecutive poiché i trader si stanno preparando per i dati del PCE. La previsione media di mercato per i dati del PCE ad aprile è un aumento dello 0,3%, con un tasso annuo del 2,8%, ma c’è un rischio al ribasso.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono rimasti stabili martedì. I futures del petrolio Brent sono saliti dello 0,1% a $83,19 al barile, mentre i prezzi dell’oro sono saliti per il terzo giorno consecutivo, aumentando dello 0,1% a $2.354,23 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Glassa</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 repostaggio dell'articolo a condizione che venga citato 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>