Tm90aXppZSBxdW90aWRpYW5lIHwgVml0YWxpayBCdXRlcmluIHN1cHBvcnRhIGxhIGJsb2NrY2hhaW4gTWVnYUVUSCwgZmluYW56aWFtZW50byBkZWwgcHJvZ2V0dG8gZGkgJDIwTTsgQmxhc3Qgw6ggYXVtZW50YXRvIGRlbCA0MCUgZG9wbyBsJ2FpcmRyb3A7IEZvcm5pdHVyYSBkaSBVU0RUIHN1IFRPTiBzdXBlcmlvcmUgYSA1MDBN

2024-06-28, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17195474951_21.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Vitalik20Buterin20supporta20la20blockchain20MegaETH20nella20nuova20area20con20un20finanziamento20del20progetto20di202020milioni20il20token20Blast2020aumentato20del204020dopo20lairdrop20lofferta20di20USDT20su20TON20ha20superato20i2050020milioni314636"><a name="Crypto Daily Digest: Vitalik Buterin supporta la blockchain MegaETH nella nuova area, con un finanziamento del progetto di $20 milioni; il token Blast è aumentato del 40% dopo l’airdrop; l’offerta di USDT su TON ha superato i 500 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Vitalik Buterin supporta la blockchain MegaETH nella nuova area, con un finanziamento del progetto di $20 milioni; il token Blast è aumentato del 40% dopo l’airdrop; l’offerta di USDT su TON ha superato i 500 milioni</h2><p>In primo luogo, esaminiamo le attività commerciali di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 27 giugno, gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno registrato deflussi di 11,4 milioni di dollari; Nel frattempo, Fidelity Bitcoin Spot ETF (FBTC) ha registrato un afflusso di 6,7 milioni di dollari, Bitwise Bitcoin Spot ETF (BITB) ha registrato un afflusso di 8 milioni di dollari, ARK 21Shares Bitcoin Spot ETF (ARKB) ha registrato un afflusso di 1,8 milioni di dollari e WisdomTree Bitcoin Spot ETF (BTCW) ha registrato un afflusso netto di 6,6 milioni di dollari.</p>
<p><strong>Vitalik Buterin supporta la nuova blockchain MegaETH, raccogliendo $20 milioni con una valutazione dei token a 9 cifre</strong><br>Shuyao Kong, co-fondatore e Chief Business Officer di MegaLabs, ha rivelato a The Block che l’azienda ha iniziato il finanziamento del round di seed a dicembre dell’anno scorso e lo ha completato a maggio di quest’anno. Kong ha dichiarato che questo round di finanziamento adotta una struttura di equità e warrant token, portando la valutazione del token diluito completamente di MegaETH a “nove cifre,” o almeno $100 milioni.</p>
<p>MegaLabs ha annunciato giovedì che Dragonfly ha guidato il round di finanziamento seed, con altri partecipanti tra cui Segment Capital, Robot Ventures, Big Brain Holdings e altri. Gli investitori angelo includono Vitalik Buterin, co-fondatore di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Joseph Lubin, fondatore e CEO di ConsenSys, e Sreem Kannan, fondatore e CEO di EigenLayer.</p>
<p>Kong ha spiegato che l’idea alla base della blockchain MegaETH deriva dal fatto che la maggior parte delle blockchain compatibili con <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM) può raggiungere solo volumi di transazioni a tre cifre al secondo (TPS), mentre l’obiettivo di MegaETH è raggiungere 100.000 TPS. MegaETH afferma di essere la prima “blockchain in tempo reale” completamente compatibile con Ethereum - “in tempo reale” significa che MegaETH può “elaborare e aggiornare i risultati in tempo reale non appena arrivano le transazioni”. Supporta un elevato throughput delle transazioni e una potente potenza di calcolo.</p>
<p>MegaETH utilizza la sicurezza di Ethereum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> Il sistema di prevenzione degli errori di MegaETH e il proprio classificatore ottimizzato consentono di ottenere prestazioni in tempo reale. Le due tecnologie chiave di MegaETH - l’architettura blockchain eterogenea e l’ambiente di esecuzione EVM ‘super ottimizzato’ - sono cruciali. MegaLabs afferma che le architetture blockchain eterogenee migliorano le prestazioni consentendo ai nodi di rete con diverse configurazioni hardware di eseguire specifici compiti, mentre gli ambienti di esecuzione EVM ultra ottimizzati spingono la throughput, la latenza e l’efficienza delle risorse ai limiti hardware.</p>
<p>Kong ha rivelato che il testnet pubblico di MegaETH sarà lanciato all’inizio dell’autunno e si prevede che il mainnet sarà lanciato entro la fine dell’anno. Quando gli è stato chiesto se i token nativi di MegaETH saranno lanciati contemporaneamente al mainnet, Kong ha dichiarato che la decisione non è ancora stata presa.</p>
<p><strong>Il token Blast è salito del 40% dopo aver ricevuto il suo primo airdrop da 2 miliardi di dollari</strong><br>Il token nativo della rete di livello 2 di Ethereum, Blast (BLAST), è aumentato del 40% dal suo lancio, superando altri airdrop molto attesi che sono entrati nel mercato nelle ultime settimane. Secondo i dati riassuntivi di Ambient Finance e della piattaforma di trading perps “Aevo”, il prezzo iniziale dell’offerta di BLAST è di $0.02 per azione, con un valore pienamente diluito (FDV) di $2 miliardi al lancio.</p>
<p>Secondo i dati di CoinMarketCap, il prezzo di BLAST è aumentato di oltre il 40%. Questo è in netto contrasto con le recenti emissioni di token di alto profilo, tra cui la rete Ethereum Layer 2 zkSync (ZK) e la interoperabilità cross-chain LayerZero (ZRO). Questi due tipi di token sono diminuiti rispettivamente del 46% e del 43% dalla loro emissione.</p>
<p>Questo airdrop ha rilasciato il 17% dell’offerta totale di BLAST, di cui il 7% è stato allocato agli utenti che collegano Ethereum, un altro 7% è stato assegnato agli utenti che hanno ‘contribuito al successo delle applicazioni decentralizzate (DApp) sulla rete’ e il 3% è stato assegnato alla Blur Foundation per futuri airdrop alla sua comunità.</p>
<p><strong>L’offerta di USDT sulla blockchain TON ha superato i 500 milioni</strong><br>Il traffico netto dello stablecoin USDT sulla rete TON ha superato i 500 milioni. Secondo il cruscotto di fornitura USDT di The Block, fino a martedì c’erano un totale di 5192,8 milioni di stablecoin USDT sulla rete di TON.</p>
<p>Circa due mesi fa, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha lanciato stablecoin ancorate al dollaro statunitense e la stablecoin XAUT dell’azienda ancorata all’oro su TON. Open Network ha annunciato attraverso il suo canale Telegram ufficiale: “Avere la possibilità di inviare facilmente dollari digitali a chiunque ovunque, come inviare un messaggio di testo, è un caso d’uso pratico del mondo reale che distingue USDT/TON.”</p>
<p>L’aumento delle attività della rete TON può essere attribuito anche alla crescente popolarità dei mini giochi crypto giocabili su Telegram. Giochi come Dotcoin, Catizen e Hamster Kombat adottano meccanismi semplici che consentono agli utenti di guadagnare monete di gioco, vincendo potenzialmente veri airdrop di token.</p>
<p>All’inizio di questo mese, il valore totale di blocco della blockchain TON ha superato i 600 milioni di dollari, che è il doppio del valore di blocco di tre settimane fa. Secondo i dati di DefiLlama, TON detiene attualmente oltre 670 milioni di dollari. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> La criptovaluta nativa della blockchain TON, , è diventata anche la nona criptovaluta più grande al mondo con un valore di mercato di 18,5 miliardi di dollari.</p>
<h2 id="h2-Tendenze20di20mercato623325"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC ha oscillato al rialzo ed è ora tornato sopra i $62.000; ETH ha mostrato una forte performance, a un solo passo dai $3.500; SOL è salito del 10% durante la giornata, guidando l’ascesa complessiva di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> token dell’ecosistema. Sul fronte macroeconomico, il mercato azionario statunitense è salito mentre oggi è iniziato il dibattito per le elezioni presidenziali statunitensi.</p>
<h3 id="h3-Hotspot20di20mercato658764"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Ecosistema Solana: VanEck ha presentato la prima richiesta per il SOL ETF, che ha stimolato un aumento di oltre il 10% in SOL durante la giornata, tornando sopra i $150. SOL ha registrato un forte aumento, portando anche ad un’impennata i token dell’ecosistema come BOME, POPCAT, WEN, RAY, JUP, ecc., con Meme sulla catena <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> che si è comportato in modo più evidente.</p>
<p>Ecosistema Ethereum: Le notizie di mercato mostrano che l’ETF ETH sarà approvato prima del 4 luglio e il tasso di cambio ETH/BTC continua a rafforzarsi. MOG, MKR, ENS e altri componenti dell’ecosistema Ethereum hanno registrato un significativo aumento.</p>
<p>Settore DePIN: il settore DePIN è generalmente aumentato, con settori come MOBILE, AKT, IO, HNT e altri che hanno registrato significativi guadagni. AKT è il token nativo di Akash Network, un mercato di cloud computing decentralizzato con un valore di mercato circolante attuale di circa $870 milioni, posizionandosi al 79º posto per valore di mercato.</p>
<h2 id="h2-Macro20Gli20investitori20stanno20osservando20i20dati20sullinflazione20e20Wall20Street20ha20chiuso20invariata20Il20mercato20asiatico2020in20rialzo20da20cinque20mesi20consecutivi77995"><a name="Macro: Gli investitori stanno osservando i dati sull’inflazione, e Wall Street ha chiuso invariata; Il mercato asiatico è in rialzo da cinque mesi consecutivi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gli investitori stanno osservando i dati sull’inflazione, e Wall Street ha chiuso invariata; Il mercato asiatico è in rialzo da cinque mesi consecutivi</h2><p>Giovedì 27 giugno, il mercato azionario statunitense ha chiuso invariato mentre gli investitori aspettavano nuovi dati sull’inflazione, indicando una continua frenata dell’attività economica e alimentando le aspettative di tagli dei tassi d’interesse. Le performance di mercato per il resto della settimana sono state relativamente deludenti, mentre venerdì si sono verificati eventi rischiosi, come il primo dibattito presidenziale tra il democratico Joe Biden e l’avversario repubblicano Donald Trump ad Atlanta.</p>
<p>Le performance dei tre principali indici sono le seguenti: il Nasdaq è salito dello 0,3%, l’S&amp;P è salito dello 0,09% e il Dow Jones è salito dello 0,09%. I partecipanti al mercato hanno espresso preoccupazioni sulla sostenibilità di questa crescita e hanno suggerito di diversificare i portafogli di investimento per proteggersi da potenziali perdite significative.</p>
<p>La scorsa settimana, il numero di richieste iniziali di sussidi di disoccupazione è sceso a 233.000, inferiore alle 236.000 previste. Inoltre, i dati finali mostrano che l’economia statunitense è cresciuta oltre le aspettative nel primo trimestre. I dati hanno mostrato che l’attività economica è continuata ma ha rallentato e il rendimento dei titoli del tesoro di riferimento a 10 e due anni è diminuito.</p>
<p>Il 28 giugno, i mercati azionari asiatici sono aumentati venerdì, segnando il quinto mese consecutivo di guadagni. Il mercato si aspetta che un rallentamento dell’inflazione negli Stati Uniti porti alla Federal Reserve il rilassamento delle politiche sui tassi di interesse quest’anno. L’indice azionario MSCI Asia Pacific escluso il Giappone è sceso dello 0,03%; Nonostante la debolezza dello yen giapponese, è stato positivo per l’indice Nikkei, con l’ultimo aumento che supera l’1%. L’indice Hang Seng di Hong Kong è sceso dello 0,1%, mentre l’indice di riferimento in Cina è sceso leggermente dello 0,05%.</p>
<p>Nel frattempo, l’indice dei prezzi al consumo delle spese personali (PCE) principali per il mese di maggio negli Stati Uniti verrà pubblicato più tardi venerdì, il che potrebbe fornire ulteriori chiarimenti sulle prospettive dei tassi d’interesse statunitensi.</p>
<p>Per quanto riguarda le materie prime, i future sul petrolio Brent sono aumentati dell’0,39% a $86,73 al barile, mentre i future sul petrolio greggio del West Texas Intermediate negli Stati Uniti sono aumentati dell’0,42% a $82,08 al barile.</p>
<p>L’oro ha faticato sotto la pressione del dollaro americano in aumento, scendendo dello 0,26% a $2.321,19 l’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 ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>