Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgw6ggaW4gZmx1dHR1YXppb25lIGUgaW4gYXVtZW50bzsgTm90Y29pbiBoYSBwcm9tb3NzbyBsJ2Fkb3ppb25lIGRlbGxlIGNyaXB0b3ZhbHV0ZSBzdSBURzsgTCdhdHRhY2NhbnRlIGRlbGxhIHZ1bG5lcmFiaWxpdMOgIGluIEdhbGEgR2FtZXMgaGE

2024-05-22, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/17163492481_14.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Notcoin20ha20guidato20ladozione20delle20criptovalute20su20Telegram20Gli20sfruttatori20di20Gala20Games20hanno20restituito202220milioni20attraverso20attacchi20con20token20Gala20Il20team20della20campagna20di20Trump20ha20espresso20accettazione20di20donazioni20in20criptovaluta982513"><a name="Crypto Daily Digest: Notcoin ha guidato l’adozione delle criptovalute su Telegram; Gli sfruttatori di Gala Games hanno restituito $22 milioni attraverso attacchi con token Gala; Il team della campagna di Trump ha espresso accettazione di donazioni in criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Notcoin ha guidato l’adozione delle criptovalute su Telegram; Gli sfruttatori di <a href="/price/gala-gala" target="_blank" class="blog_inner_link">Gala</a> Games hanno restituito $22 milioni attraverso attacchi con token Gala; Il team della campagna di Trump ha espresso accettazione di donazioni in criptovaluta</h2><p>Esaminiamo l’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 21 maggio l’afflusso dello spot ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di Fidelity (FBTC) è stato di $25,8 milioni, mentre l’uscita dello spot ETF Bitcoin di Bitwise (BITB) è stata di $4,2 milioni.</p>
<p>La crescita esplosiva di Notcoin ha spinto l’adozione delle criptovalute su Telegram</p>
<p>I giochi blockchain costruiti su TON stanno attirando milioni di utenti su Telegram, con giochi come Notcoin in testa. La crescita esplosiva di Notcoin ha attirato oltre 30 milioni di utenti in meno di due mesi e ha stabilito un portafoglio crittografico basato su una rete aperta.</p>
<p>Con la popolarità dei giochi virali come Notcoin, la vasta base di utenti di Telegram si è dimostrata un terreno fertile per l’adozione delle criptovalute. Il gioco di posizionamento in cui gli utenti cliccano sullo schermo per guadagnare token non ha attirato l’attenzione del 3% degli utenti di Telegram a utilizzare Web3. Successivamente, il token NOT è stato quotato su un noto exchange di criptovalute, portando ricchezza inaspettata ai giocatori occasionali.</p>
<p>Anche gli sviluppatori di giochi stanno prestare attenzione all’ecosistema TON. Micha, CEO e fondatore di Elympics, un fornitore di infrastrutture per giochi blockchain, ha dichiarato che i giochi <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sono pronti ad attirare nuovi utenti di criptovalute.</p>
<p>Dąbrowski ha detto a Cointelgraph che l’infrastruttura basata su blockchain affronta le sfide che i game developer incontrano in termini di meccanismi di monetizzazione, consentendo agli studi di utilizzare portafogli criptati per incentivare e attirare i giocatori. Elympics vede l’enorme potenziale dell’ecosistema TON, mirato ad aiutare gli studi e i developer a distribuire giochi Web3 su queste piattaforme.</p>
<p>Il CEO di Elympics ha aggiunto che le caratteristiche di Web3 stanno rivitalizzando i tipi di giochi inattivi. La valuta virtuale guadagnata dai giocatori nel gioco sta ora venendo monetizzata, consentendo agli utenti di ottenere proprietà e valore dal gioco.</p>
<p>L’attaccante della vulnerabilità di Gala Games ha restituito $22 milioni</p>
<p>Attacchi di vulnerabilità segnalati in precedenza legati a Gala Games. Un attaccante ha coniato 200 milioni di dollari. <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> token ma solo una parte di loro con successo venduta. Gala Games ha ora ricevuto circa $22 milioni in Ether.</p>
<p>Il 21 maggio, il portafoglio dell’attaccante ha restituito 5913,2 ETH, del valore di 22,3 milioni di dollari - vicino al valore di mercato dei 600 milioni di GALA venduti il giorno prima.</p>
<p>In merito a questa situazione imprevista, Gala Games ha spiegato anche sui social media che i portafogli interessati sono stati congelati e hanno utilizzato la nuova funzione “GalaChain’s Block List Protocol”, congelando efficacemente 4,4 miliardi di GALA su 5 miliardi di GALA entro 45 minuti. Gala Games non ha ancora confermato pubblicamente l’identità o il metodo di attacco del bersaglio, ma alcuni membri della comunità ritengono che l’attacco sia stato effettuato da un contraente di sicurezza che ha commesso un errore dopo non aver utilizzato una VPN per connettersi al portafoglio.</p>
<p>Il team della campagna di Trump ha espresso accettazione di donazioni criptate</p>
<p>L’ex presidente degli Stati Uniti Donald Trump sta attualmente affrontando accuse penali da quattro giurisdizioni e, di fronte a questa situazione, ha annunciato che la sua campagna presidenziale del 2024 accetterà donazioni in criptovaluta.</p>
<p>In un avviso del 21 maggio, il team della campagna Trump 2024 ha dichiarato di aver lanciato una pagina di raccolta fondi che accetta piattaforme come Bitcoin, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, DOGE, SHIB, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, SOL e altro ancora. La dichiarazione cita l’attacco della senatrice Elizabeth Warren alle criptovalute, affermando senza prove che lei è la “rappresentante ufficiale” del presidente degli Stati Uniti Joe Biden in Congresso.</p>
<p>Trump ha detto che garantirà che i partecipanti possano donare alla sua campagna in forma di criptovaluta. A meno di sei mesi dal giorno delle elezioni, Trump è il candidato previsto per il Partito Repubblicano come Presidente degli Stati Uniti nel 2024. Potrebbe affrontare il candidato democratico, il presidente Biden.</p>
<p>Anche se Trump ha accettato donazioni in criptovaluta, la pagina “Questioni” sul suo sito web di campagna non menzionava specificamente asset digitali o blockchain quando è stata pubblicata. Il presidente Biden raramente rilascia dichiarazioni pubbliche sulle criptovalute, ma ha firmato un ordine esecutivo per istituire un quadro normativo per gli asset digitali nel 2022.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020in20fase20di20fluttuazione20e20crescita20e20il20concetto20di20Meme20sta20ottenendo20risultati20positivi42194"><a name="Tendenze di mercato: il mercato è in fase di fluttuazione e crescita, e il concetto di Meme sta ottenendo risultati positivi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è in fase di fluttuazione e crescita, e il concetto di Meme sta ottenendo risultati positivi</h2><p>Performance di BTC e ETH: Bitcoin si sta consolidando sopra i $70.000, mostrando un forte supporto. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha anche superato i $3.800 in un momento, indicando una forte fiducia di mercato in queste valute principali.</p>
<p>Impatto macroeconomico: le azioni statunitensi hanno raggiunto un massimo storico e i discorsi accomodanti dei funzionari della Federal Reserve hanno aumentato le aspettative di mercato per un taglio dei tassi a settembre. Questi fattori potrebbero ulteriormente guidare la crescita del mercato delle criptovalute.</p>
<h3 id="h3-Punti20Caldi20di20Mercato353168"><a name="Punti Caldi di Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi di Mercato:</h3><p><strong>Monete concetto meme:</strong><br>Performance eccezionale: le criptovalute basate su Ethereum come PEPE, PEOPLE, FLOKI, WOJAK, MOG, ecc. hanno mostrato prestazioni eccezionali.</p>
<p>Le valute dello stagflazione, come WIF e MANEKI sul <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain, hanno mostrato una performance relativamente in ritardo.</p>
<p><strong>Monete di concetto sociale:</strong><br>Le valute che hanno registrato una crescita significativa includono DEGEN, HIGHER, Only1 e altre che si sono comportate bene.</p>
<p>Notizie sugli investimenti: Il protocollo sociale Farcaster sulla Base chain ha ricevuto investimenti da a16z e Paradigm, aumentando ulteriormente la fiducia del mercato nelle monete basate su concetti sociali.</p>
<p>Il prezzo del Protocollo di Nomi di Dominio Ethereum (ENS) è aumentato significativamente:</p>
<p>Supporto di Vitalik Buterin: Vitalik Buterin ha menzionato più volte ENS e lo ha definito uno strumento importante per unificare le diverse reti di Layer2 in Ethereum, fornendo supporto per il valore a lungo termine di ENS.</p>
<p><strong>Rete Layer2:</strong><br>Zksync Programma di Airdrop: Zksync prevede di effettuare airdrop di token a giugno, con un totale di 21 miliardi di token e una valutazione di mercato prevista di $10 miliardi.</p>
<p>Confronto della valutazione di mercato: Le reti Layer2 popolari come ARB, OP e STRK hanno valutazioni di circa $12 miliardi nello stesso periodo, indicando un forte interesse di mercato nel progetto Layer2.</p>
<p>Mercato dei futures: Aevo prevede che i token futures di Zksync siano stati quotati sul mercato, con un prezzo attuale di $0.69, offrendo agli investitori l’opportunità di pianificare in anticipo.</p>
<p>L’attuale tendenza complessiva del mercato delle criptovalute è fluttuante e in crescita, guidata da diverse notizie positive.<br>Valute mainstream come BTC ed ETH hanno registrato performance stabili, e varie valute concetto calde hanno visto aumenti significativi. In particolare, gli investimenti e lo sviluppo delle reti Layer2 e dei protocolli sociali dimostrano l’alta attenzione e le aspettative del mercato verso questi settori emergenti. Si consiglia agli investitori di monitorare attentamente queste aree calde mantenendo al contempo sensibilità ai cambiamenti dell’ambiente macroeconomico, per adeguare tempestivamente le strategie di investimento.</p>
<h2 id="h2-Macro20le20azioni20statunitensi20hanno20chiuso20in20rialzo20i20mercati20asiatici20sono20leggermente20aumentati20e20i20prezzi20del20petrolio20hanno20continuato20a20diminuire385977"><a name="Macro: le azioni statunitensi hanno chiuso in rialzo, i mercati asiatici sono leggermente aumentati e i prezzi del petrolio hanno continuato a diminuire" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: le azioni statunitensi hanno chiuso in rialzo, i mercati asiatici sono leggermente aumentati e i prezzi del petrolio hanno continuato a diminuire</h2><p>Il 21 maggio, Reuters ha riferito che la borsa statunitense ha chiuso leggermente in rialzo martedì, con l’S&amp;P 500 e il Nasdaq che hanno raggiunto nuovi massimi storici. Gli investitori hanno valutato gli ultimi commenti dei funzionari della Federal Reserve per trovare indizi sul momento dei tagli ai tassi di interesse, mentre si avvicinano i guadagni trimestrali di Nvidia.</p>
<p>In particolare, i tre principali indici: l’indice Dow Jones è salito dello 0,17%, l’indice Standard&amp;Poor’s è salito dello 0,25% e l’indice Nasdaq è salito dello 0,22%.</p>
<p>Nvidia rilascerà i suoi risultati dopo la chiusura delle contrattazioni di mercoledì. Essendo la terza azienda più grande di Wall Street per valore di mercato, queste informazioni potrebbero costituire un importante catalizzatore di mercato e testeranno se l’importante aumento delle azioni legate all’intelligenza artificiale può essere sostenuto.</p>
<p>Secondo i dati della società di analisi delle opzioni Trade , si prevede che le opzioni di Nvidia fluttueranno dell’8,7%, ovvero un valore di mercato di 200 miliardi di dollari, entro venerdì. Il prezzo delle azioni di questo produttore di chip è aumentato dello 0,64% martedì e, dopo essere salito di quasi il 240% nel 2023, è aumentato di circa il 93% finora quest’anno.</p>
<p>Gli investitori stanno anche prestando attenzione ai verbali dell’ultima riunione di politica della Federal Reserve prevista per mercoledì, dopo che diversi funzionari della Federal Reserve martedì hanno rafforzato la migliore posizione della Fed di pazienza prima di iniziare i tagli dei tassi di interesse.</p>
<p>I responsabili della Federal Reserve hanno affermato martedì che la Federal Reserve dovrebbe aspettare ancora qualche mese per assicurarsi che l’inflazione torni realmente al target del 2% prima di abbassare i tassi di interesse.</p>
<p>I mercati azionari asiatici sono aumentati leggermente mercoledì, mentre gli investitori ansiosi osavano sperare che il gigante dell’Intelligenza Artificiale Nvidia potesse soddisfare aspettative estremamente alte rimanendo cauti sulle prospettive dei tassi di interesse negli Stati Uniti e nel Regno Unito. L’indice azionario MSCI Asia Pacific è salito dello 0,4% ed è in aumento da quattro settimane consecutive, raggiungendo il suo punto più alto in due anni. L’indice Nikkei in Giappone è sceso dello 0,6%.</p>
<p>La Banca della Nuova Zelanda ha valutato il suo problema di inflazione, affermando che i tassi di interesse devono rimanere alti per un periodo più lungo per far fronte agli shock del mercato locale. Con l’aumentare dei rendimenti dei titoli di stato, il dollaro neozelandese è salito dello 0,9% rispetto al dollaro americano, raggiungendo un massimo di un mese di $0,6151.</p>
<p>A causa della minaccia dell’intervento giapponese che ostacola la crescita dell’USD/JPY, il tasso di cambio USD/JPY è rimasto invariato a 156.20. I dati pubblicati dal Ministero dell’Economia, del Commercio e dell’Industria giapponese mostrano che la svalutazione dello yen ha promosso le esportazioni, ma ha anche innescato l’inflazione dei prezzi di input e ha influenzato la fiducia delle imprese.</p>
<p>I dati sull’inflazione nel Regno Unito saranno pubblicati in seguito, il che potrebbe determinare se la Banca d’Inghilterra implementerà politiche monetarie espansive già a giugno o se aspetterà fino ad agosto. Si prevede che l’inflazione dei prezzi al consumo di base rallenti dal 4,2% di marzo al 3,6% di aprile e qualsiasi tasso di inflazione più basso ridurrà la possibilità di un taglio dei tassi a giugno e potrebbe mettere sotto pressione la sterlina.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono scesi per il terzo giorno di negoziazione consecutivo mercoledì a causa delle aspettative di mercato che la Federal Reserve possa mantenere tassi di interesse elevati per un periodo prolungato a causa dell’inflazione sostenuta, il che potrebbe influire sul consumo di carburante nel paese più grande consumatore di petrolio del mondo. I futures del petrolio Brent sono scesi di 43 centesimi, o dello 0,5%, a $82,45 al barile. I futures del petrolio greggio West Texas Intermediate (WTI) negli Stati Uniti sono scesi di 50 centesimi, o dello 0,6%, a $78,16. Martedì i prezzi del petrolio sono scesi di circa l’1%.</p>
<p>Dopo aver raggiunto un massimo storico di $2.449,89 all’inizio di questa settimana, i prezzi dell’oro sono rimasti a $2.424 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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 ripubblicare l'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>