Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgc3RhIGdlbmVyYWxtZW50ZSBkaW1pbnVlbmRvOyBBZXRoaXIgaGEgbGFuY2lhdG8gdW5hIHJldGUgY2xvdWQgZGVjZW50cmFsaXp6YXRhIHN1IEV0aGVyZXVtOyBORUFSIEZvdW5kYXRpb24gaGEgaXN0aXR1aXRvIE51ZmZsZSBMYWJzLCByYWNjb2d

2024-06-14, 03:46

<p><img src="https://gimg2.gateimg.com/image/article/17183366841_10.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20Aethir20ha20lanciato20una20rete20cloud20decentralizzata20sulla20mainnet20di20Ethereum20La20Fondazione20NEAR20ha20creato20Nuffle20Labs20raccogliendo201320milioni20di20finanziamenti20A20causa20degli20sfruttatori20che20hanno20coniato20120miliardo20di20nuovi20token20i20prezzi20di20HLG20sono20diminuiti20di20oltre20il2060778689"><a name="Riassunto giornaliero di Crypto: Aethir ha lanciato una rete cloud decentralizzata sulla mainnet di Ethereum; La Fondazione NEAR ha creato Nuffle Labs, raccogliendo $13 milioni di finanziamenti; A causa degli sfruttatori che hanno coniato 1 miliardo di nuovi token, i prezzi di HLG sono diminuiti di oltre il 60%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: Aethir ha lanciato una rete cloud decentralizzata sulla mainnet di Ethereum; La Fondazione NEAR ha creato Nuffle Labs, raccogliendo $13 milioni di finanziamenti; A causa degli sfruttatori che hanno coniato 1 miliardo di nuovi token, i prezzi di HLG sono diminuiti di oltre il 60%.</h2><p>Innanzitutto, esaminiamo le 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 13 giugno, gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno continuato a registrare deflussi di 61,5 milioni di dollari; Nel frattempo, gli ETF Fidelity Bitcoin spot (FBTC) hanno registrato deflussi di 106,4 milioni di dollari, gli ETF Bitwise Bitcoin spot (BITB) hanno registrato un afflusso di 9,8 milioni di dollari e gli ETF ARK 21 Shares Bitcoin spot (ARKB) hanno registrato un afflusso di 52,7 milioni di dollari.</p>
<p><strong>Aethir ha lanciato una rete cloud decentralizzata sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet</strong><br>Aethir, un fornitore di rete infrastrutturale fisica decentralizzata (DePIN), ha annunciato che la sua rete di calcolo cloud decentralizzata è stata ufficialmente lanciata sulla mainnet di Ethereum. Le imprese, i data center, altri fornitori di cloud e gli operatori di mining di criptovalute possono contribuire risorse GPU inutilizzate alla soluzione di GPU come servizio di Aethir.</p>
<p>Aethir consente alle aziende e agli sviluppatori di noleggiare risorse di calcolo dalle loro reti di fornitori per supportare la formazione di modelli di intelligenza artificiale (IA) o la presentazione di contenuti digitali su larga scala. Aethir utilizza <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> per implementare la sua funzione di staking attraverso token ATH nativi e utilizza Arbitrum (ARB) per pagamenti rapidi a fornitori di calcolo e nodi di verifica, garantendo qualità.</p>
<p>Durante la fase di testnet, Aethir ha attirato oltre 500.000 utenti, ha raggiunto vendite di nodi per $146 milioni e ha ricevuto il supporto di Nvidia, Super Micro, HPE e Foxconn.</p>
<p>Riguardo alla sicurezza dei dati e alla privacy, il co-fondatore di Aethir, Mark Rydon, ha dichiarato che le misure di sicurezza di rete includono il controllo dell’accesso alla rete e gli attacchi anti-DDoS, con firewall hardware dedicati che proteggono la sicurezza dei dati. I clienti sono sempre i proprietari e gli utenti dei dati, e questi dati vengono mantenuti sicuri e riservati non solo per i visitatori esterni, ma anche per i visitatori interni.</p>
<p><strong>NEAR Foundation ha istituito un’entità indipendente, Nuffle Labs, raccogliendo $13 milioni di finanziamenti</strong><br>La NEAR Foundation ha annunciato la creazione di un’entità indipendente chiamata Nuffle Labs e ha raccolto con successo 13 milioni di dollari di finanziamenti strategici. Nuffle Labs è responsabile della costruzione del livello di disponibilità dei dati (NEAR DA), del livello di finalizzazione rapida di NEAR (NFFL) e di altri prodotti della suite modulare di prodotti NEAR. Questo finanziamento è guidato da Electric Capital, con finanziamenti strategici dalla NEAR Foundation e la partecipazione di più istituzioni di investimento.</p>
<p>Altri investitori includono Canonical Crypto, Fabric Ventures, Robot Ventures, Caladan, Lyrik Ventures e investitori angelici come Jordi Alexander di Selini, Bowen Wang di NEAR, Sriram Kannan di EigenLayer, Sam Kazemian da <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, e Sandeep Nailwal da <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygona</a>.</p>
<p>Come entità indipendente, Nuffle Labs può prendere decisioni più flessibili e garantire che i prodotti modulari NEAR rimangano competitivi. L’azienda sfrutterà i vantaggi degli ecosistemi NEAR Foundation, Ethereum e EigenLayer per migliorare l’efficienza e la resilienza dell’ecosistema NEAR.</p>
<p>La Fondazione NEAR è responsabile della supervisione del protocollo NEAR, una piattaforma che consente agli sviluppatori di creare applicazioni decentralizzate. Nel frattempo, il token NEAR è diminuito del 4,9% nelle ultime 24 ore e attualmente è quotato a $5,95.</p>
<p><strong>A causa degli sfruttatori che coniano 1 miliardo di nuovi token, i prezzi di HLG sono diminuiti di oltre il 60%</strong><br>Secondo i dati di CoinGecko, i token nativi del protocollo Hologram (HLG) hanno subito un calo del prezzo del 60% dopo che un attore malintenzionato ha sfruttato una vulnerabilità per coniare 1 miliardo di token HLG. I dati on-chain mostrano che il portafoglio ENS acc01ade.eth è stato coinvolto in questo attacco. La pagina Github mostra che il portafoglio è anche un contributore al progetto.</p>
<p>In base ai prezzi di mercato attuali, il valore dell’1 miliardo di HLG sottratti dagli sfruttatori è leggermente superiore a 6,7 milioni di dollari. Il protocollo Hologram è descritto sul suo sito web come una soluzione per raggiungere un singolo indirizzo contrattuale su tutte le blockchain EVM, garantendo una tokenizzazione coerente, interoperabilità senza soluzione di continuità e trasferimento di asset cross-chain sicuro.</p>
<p>Il team di Holograph ha dichiarato di aver risolto la vulnerabilità e sta lavorando con gli scambi centralizzati per bloccare gli account associati agli sfruttatori.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020generalmente20in20calo20e20le20prestazioni20di20MAGA20sono20impressionanti956234"><a name="Tendenze di mercato: il mercato è generalmente in calo e le prestazioni di MAGA sono impressionanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è generalmente in calo e le prestazioni di MAGA sono impressionanti</h2><p>BTC attualmente è in fase di consolidamento al di sotto dei $67.000, il che indica che il mercato potrebbe essere in attesa di nuovi catalizzatori.</p>
<p>ETH è sceso sotto i $3.500, indicando un debole sentiment di mercato. Si prevede che l’ETF di ETH passerà quest’estate, il che potrebbe diventare un importante fattore positivo e merita attenzione.</p>
<p>La maggior parte delle Altcoin sono tornate ai loro prezzi pre-CPI, indicando un sentimento di mercato cauto.</p>
<h3 id="h3-Macroeconomia862773"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Il mercato azionario statunitense è volatile. Anche se il calo dei dati sulla PPI è un piccolo aspetto positivo, non ha avuto un impatto significativo sul mercato. Gli investitori dovrebbero continuare a monitorare i dati sui CPI e le tendenze della politica della Federal Reserve, poiché questi fattori hanno un impatto più significativo sul mercato.</p>
<h3 id="h3-Punti20Caldi20del20Mercato290084"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>CRV: Il fondatore ha scommesso oltre 100 milioni di dollari in spedizioni CRV, causando insoddisfazione nella comunità e provocando un calo del prezzo del 40% a breve termine. Anche se ha estinto la maggior parte dei suoi debiti on-chain, il prezzo non è aumentato significativamente, indicando una mancanza di fiducia di mercato.</p>
<p><strong>Settore dei meme:</strong><br>MAGA è aumentato di oltre il 20% nel corso della giornata, probabilmente a causa del compleanno di Trump il 14 giugno, e il mercato ha colto l’opportunità di esaltarsi. Potrebbe continuare a salire nel breve termine, ma la volatilità è alta.</p>
<p>BOME è aumentato del 15% e ha lanciato contratti su Coinbase. Questa notizia potrebbe continuare a far salire il suo prezzo.</p>
<p>Ecosistema TON: TON è salito del 10% nel corso della giornata, raggiungendo un nuovo massimo storico. Il TVL dell’ecosistema ha superato i 550 milioni di dollari, raggiungendo anch’esso un massimo storico, dimostrando una forte domanda di mercato. TON attualmente si comporta in modo forte ed è adatto per il mantenimento a medio e lungo termine, ma è importante prestare attenzione ai cambiamenti nel sentiment di mercato.</p>
<p>Il sentimento attuale del mercato è piuttosto complesso, con BTC ed ETH in chiave di prezzo, e le prestazioni di Altcoin sono differenziate. Dati macroeconomici come CPI e le politiche della Fed rimangono fattori di influenza chiave. Per quanto riguarda i temi caldi, il settore delle Meme coin ha significative fluttuazioni ed è adatto per il trading a breve termine; TON si comporta bene ed è adatto per il possesso a medio-lungo termine. Gli investitori dovrebbero fare adattamenti flessibili in base alle loro preferenze di rischio e ai cambiamenti di mercato.</p>
<h2 id="h2-Macro20Azioni20tecnologiche20guidano20i20guadagni20nel20Nasdaq20e20nellSampP2050020Il20mercato20asiatico2020sceso20nelle20prime20ore20di20contrattazione20Lo20yen20giapponese20fluttua20prima20della20decisione20della20banca20centrale985653"><a name="Macro: Azioni tecnologiche guidano i guadagni nel Nasdaq e nell’S&amp;P 500; Il mercato asiatico è sceso nelle prime ore di contrattazione; Lo yen giapponese fluttua prima della decisione della banca centrale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Azioni tecnologiche guidano i guadagni nel Nasdaq e nell’S&amp;P 500; Il mercato asiatico è sceso nelle prime ore di contrattazione; Lo yen giapponese fluttua prima della decisione della banca centrale</h2><p>Il 13 giugno, gli indici S&amp;P 500 e NASDAQ hanno raggiunto nuovi massimi di chiusura per il quarto giorno consecutivo di negoziazione, mentre le azioni tecnologiche hanno continuato a trainare l’intero mercato al rialzo. La settimana scorsa il numero di richieste di sussidio di disoccupazione negli Stati Uniti è aumentato e un altro rapporto ha mostrato una diminuzione inattesa dei prezzi al produttore nel mese di maggio, aumentando ulteriormente le aspettative di mercato per il prossimo taglio dei tassi d’interesse della Federal Reserve.</p>
<p>I dati specifici mostrano che l’indice Dow Jones è sceso dello 0,2%, l’indice S&amp;P 500 è salito dello 0,2% e l’indice Nasdaq è salito dello 0,3%. Il settore tecnologico dell’indice S&amp;P 500 è salito dell’1,4%, mentre l’indice dei semiconduttori è salito dell’1,5%, entrambi raggiungendo nuovi massimi di chiusura storici.</p>
<p>Secondo lo strumento FedWatch della Chicago Mercantile Exchange, i mercati finanziari stimano attualmente una probabilità del 60,5% che la Federal Reserve riduca il suo obiettivo di tasso dei fondi federali di 25 punti base a settembre.</p>
<p>Il 14 giugno i mercati azionari asiatici hanno registrato cali venerdì, poiché la Federal Reserve ha ridotto le aspettative di tagli dei tassi di interesse dopo che i dati sull’inflazione degli Stati Uniti sono stati inferiori alle aspettative, suscitando preoccupazioni tra gli investitori sull’outlook dei tassi di interesse degli Stati Uniti. Allo stesso tempo, lo yen ha mostrato instabilità prima della riunione della politica della Banca del Giappone.</p>
<p>Influenzato dai commenti falchi della Federal Reserve questa settimana, il dollaro statunitense si sta mantenendo intorno ad un massimo di un mese, mentre l’incertezza politica in Europa continua ad esercitare pressione sull’euro.</p>
<p>L’indice azionario MSCI Asia Pacific è sceso dello 0,48%. Anche il mercato azionario cinese ha avuto una performance negativa, con le azioni dei titoli di prima categoria che sono scese dello 0,3% e l’indice Hang Seng di Hong Kong che è sceso dello 0,79%. L’indice Nikkei del Giappone è sceso leggermente dello 0,03%, con lo yen che si è leggermente indebolito a 157,185 yen per dollaro nelle prime contrattazioni, in quanto il mercato si aspettava che la Banca del Giappone mantenesse invariati i tassi di interesse ultrabassi.</p>
<p>La Bank of Japan potrebbe mantenere i tassi di interesse ultrabassi al suo incontro di venerdì, ma sta considerando se iniziare a ridurre il suo enorme bilancio per ritirarsi gradualmente dalle politiche di stimolo monetario su larga scala. Tuttavia, a causa di una debole domanda e dei dubbi su se la Bank of Japan possa mantenere il suo obiettivo di inflazione del 2%, la normalizzazione della politica monetaria accomodante sta affrontando delle sfide.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono diminuiti venerdì, ma si prevede che otterranno il loro primo aumento settimanale in quattro settimane mentre il mercato valuta l’impatto dei tassi di interesse elevati a lungo termine negli Stati Uniti e le solide prospettive per la domanda di petrolio greggio e carburante quest’anno. I futures del petrolio greggio Brent sono diminuiti dello 0,62% a $82,26 al barile, mentre i futures del petrolio greggio degli Stati Uniti West Texas Intermediate (WTI) sono diminuiti dello 0,69% a $78,08 al barile.</p>
<p>A causa dei report sull’Indice dei prezzi alla produzione (PPI) inferiori alle aspettative, il prezzo dell’oro è sceso rispetto al dollaro statunitense. I prezzi dell’oro spot sono diminuiti dello 0,8% a 2.303,15 dollari 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 Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>