Tm90aXppZSBxdW90aWRpYW5lIHwgTGUgY29tbWlzc2lvbmkgRVRIIGhhbm5vIHJhZ2dpdW50byB1biBudW92byBtaW5pbW8gYSBmYXNpIGFsdGVybmUsIGNvbiB1biBlY29zaXN0ZW1hIEVUSCBmb3J0ZTsgSWwgcG9ydGFsZSBXZWIzIGxhbmNpYXRvIGRhIEdvb2dsZSBDbG91ZCBoYSBzdXNjaXRhdG8gcG9sZW1pY2hlIG5lbGwnaW5kdXN

2024-04-29, 04:25

<p><img src="https://gimg2.gateimg.com/image/article/171436461129.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20le20commissioni20di20Ethereum20sono20state20abbassate20al20livello20pi20basso20degli20ultimi20620mesi20la20stagione20delle20altcoin20potrebbe20essere20anticipata20il20portale20Web320lanciato20da20Google20Cloud20ha20suscitato20polemiche20nellindustria20delle20criptovalute885225"><a name="Riassunto giornaliero delle criptovalute: le commissioni di Ethereum sono state abbassate al livello più basso degli ultimi 6 mesi, la “stagione delle altcoin” potrebbe essere anticipata; il portale Web3 lanciato da Google Cloud ha suscitato polemiche nell’industria delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: le commissioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sono state abbassate al livello più basso degli ultimi 6 mesi, la “stagione delle altcoin” potrebbe essere anticipata; il portale <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> lanciato da Google Cloud ha suscitato polemiche nell’industria delle criptovalute</h2><p>Prima di tutto, diamo un’occhiata all’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 26 aprile (venerdì scorso), i fondi dello spot ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di Grayscale (GBTC) sono usciti per $82.4 milioni; Nel frattempo, i deflussi del Fidelity Bitcoin spot ETF (FBTC) sono stati di $2.8 milioni, i deflussi del Bitwise Bitcoin spot ETF (BITB) sono stati di $3.8 milioni, gli afflussi dell’ARK 21Shares Bitcoin spot ETF (ARKB) sono stati di $5.4 milioni e i netti afflussi del WisdomTree Bitcoin spot ETF (BTCW) sono stati di $6.6 milioni.</p>
<p>La diminuzione del volume di transazioni e dello sblocco del token su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Le problematiche di congestione della rete Ethereum hanno portato a un temporaneo abbassamento dei costi di rete; il prezzo di ETH è attualmente pari a $3.223,53, con un aumento del 2,6% nell’arco di 7 giorni. Nonostante la crescita dei prezzi di Ethereum, le commissioni di transazione sulla rete Ethereum sono scese a un minimo di sei mesi. Gli analisti della piattaforma di analisi crittografica Santiment suggeriscono che ciò potrebbe indicare un aumento degli Altcoin.</p>
<p>Al 27 aprile, il costo medio delle transazioni Ethereum è sceso a $1.12. Santiment ritiene che i trader siano sempre stati indecisi tra la sensazione che le criptovalute stiano per ‘atterrare sulla luna’ e i cicli di sentiment bearish, che possono essere osservati attraverso le commissioni di trading.</p>
<p>Secondo i dati di Ultrasound.money, negli ultimi 30 giorni sono stati emessi 74.458 nuovi ETH, mentre solo 57.516 ETH sono stati distrutti, aumentando la fornitura netta di 16.979 nuovi Ethereum.</p>
<p>Questo contrasta nettamente con i cinque mesi precedenti, quando ETH ha continuato a sgonfiarsi. Nonostante l’aumento recente dell’inflazione basata su ETH, oltre 437.000 ETH sono stati distrutti dal 15 settembre 2022, quando Internet si è spostato verso i meccanismi di consenso Proof of Stake (noti come “Merge”).</p>
<p>Google Cloud ha recentemente lanciato un portale Web3 che include strumenti testnet, set di dati blockchain e risorse di apprendimento per sviluppatori, ma l’industria cripto ha risposto in modo diverso a questo.</p>
<p>Secondo il suo sito web, gli sviluppatori possono accedere a vari prodotti e ricevere token di testnet dal dispiegamento e dalla prova delle loro applicazioni decentralizzate su Ethereum testnet Sepolia e Holesky. Il portale fornisce anche un piano di apprendimento che include tutorial su come sviluppare NFT, implementare programmi di fedeltà Web3 e come proteggere gli asset digitali attraverso il calcolo multi-party.</p>
<p>Recentemente, Google ha effettivamente fatto alcuni progressi nell’industria Web3. All’inizio del 2024, Google ha aggiornato la sua politica per consentire la pubblicità di determinati prodotti cripto sui principali motori di ricerca, tra cui gli Exchange Traded Funds di Bitcoin. Di recente, Google ha ampliato la sua funzionalità per consentire agli utenti di cercare i saldi dei portafogli su più blockchain, come Bitcoin, Arbitrum, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, e <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>.</p>
<p>L’economia dei token dei progetti di tracciamento è essenziale per gli investitori cripto, e i diversi token sbloccati a maggio sono molto interessanti, specialmente l’altamente pubblicizzato Python Network - Python, che vale oltre 1 miliardo di dollari, sbloccherà il primo set di token ai partecipanti dell’ecosistema entro tre settimane, fino a 1,25 miliardi di dollari.</p>
<p>Oltre a Python Network, diversi altri progetti cripto hanno in programma di sbloccare token del valore di miliardi di dollari. Secondo i dati di Token.Unlocks, di seguito sono riportati alcuni token importanti che saranno sbloccati a maggio:</p>
<p>Memeland sbloccerà $150 milioni di Memecoins il 3 maggio; <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> sbloccherà $100 milioni di APT il 12 maggio;</p>
<p>Arbitrum sbloccherà $100 milioni di ARB il 16 maggio; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> sbloccherà $325 milioni di AVAX il 22 maggio; STRK (Starknet) sbloccherà l’8,8% della sua offerta circolante il 15 maggio.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020volatile20e20lecosistema20ETH20mostra20una20forte20performance652464"><a name="Tendenze di mercato: il mercato è volatile e l’ecosistema ETH mostra una forte performance." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è volatile e l’ecosistema ETH mostra una forte performance.</h2><p>Il BTC ha recentemente mostrato un trend volatile, con il focus del mercato principalmente sull’ecosistema di Ethereum. Per quanto riguarda la macroeconomia, il mercato azionario statunitense ha ripreso, con previsioni di mercato per un taglio dei tassi di interesse di 35 punti base quest’anno e un taglio più significativo di 60 punti base previsto l’anno prossimo. Questo cambiamento nelle aspettative macroeconomiche potrebbe influenzare il mercato delle criptovalute, in particolare sull’attrattiva degli asset rischiosi.</p>
<h3 id="h3-Punti20caldi20del20mercato550638"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p>Prezzi ed entusiasmo di mercato di Ethereum: ETH è salito ieri, superando i 3.300 dollari in un momento, mentre il tasso di cambio ETH/BTC ha superato anche lo 0,05. Il mercato sta speculando sulla possibilità di superare gli ETF spot di ETH entro la fine di maggio, aumentando le aspettative di domanda di ETH.</p>
<p>Tuttavia, l’attività di trading attuale sulla catena ETH non è attiva, manifestata da commissioni di gas più basse, il che potrebbe indicare che gli acquisti speculativi influenzano maggiormente l’aumento del prezzo a breve termine.</p>
<p>L’ecosistema Ethereum ha mostrato un’eccezionale performance in progetti correlati: i protocolli di ristaking correlati a Ethereum, come SSV e ETHFI, hanno mostrato incrementi di prezzo. Allo stesso tempo, i protocolli di Layer2 di Ethereum, come <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> (OP) e Strike (STRK), hanno dimostrato anch’essi incrementi di prezzo. Da notare in particolare, questa settimana il protocollo OP sbloccherà token per un valore di 60 milioni di dollari, il che potrebbe influenzarne i prezzi di mercato.</p>
<p>L’ascesa del concetto di deposito: i token del settore del deposito come HNT e MOBILE hanno mostrato aumenti significativi dei prezzi. Inoltre, i token precedentemente rilasciati <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> I telefoni SAGA basati su Depin hanno ottenuto un ritorno sugli investimenti attraverso gli airdrop di token Meme, dimostrando l’interesse del mercato e il potenziale di investimento in Depin e tecnologie correlate.</p>
<p>Con le aspettative di mercato per gli ETF ETH spot e la continua attenzione all’ecosistema Ethereum, insieme a positive aspettative macroeconomiche, il mercato cripto potrebbe continuare a sperimentare volatilità nelle prossime settimane. Gli investitori dovrebbero monitorare da vicino le tendenze di politica rilevanti, gli eventi di sblocco di mercato e i dati in catena, tutti fattori che potrebbero influire sul sentiment di mercato e sui prezzi dei token. Gli investitori sono invitati a rimanere cauti, prestare attenzione alle tendenze di mercato e adeguare le strategie di investimento in modo tempestivo per far fronte alle possibili fluttuazioni di mercato.</p>
<h2 id="h2-Macro20Le20prestazioni20del20mercato20azionario20statunitense20sono20state20inferiori20alle20aspettative20mentre20il20mercato20asiatico20ha20aperto20bene20luned20Il20tasso20di20cambio20dello20yen20giapponese2020sceso20al20di20sotto20di20un20livello20critico203391"><a name="Macro: Le prestazioni del mercato azionario statunitense sono state inferiori alle aspettative, mentre il mercato asiatico ha aperto bene lunedì. Il tasso di cambio dello yen giapponese è sceso al di sotto di un livello critico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le prestazioni del mercato azionario statunitense sono state inferiori alle aspettative, mentre il mercato asiatico ha aperto bene lunedì. Il tasso di cambio dello yen giapponese è sceso al di sotto di un livello critico</h2><p>Lo scorso venerdì 26 aprile, la sovravalutazione del mercato azionario statunitense ha deluso gli investitori, specialmente perché diverse giganti tecnologiche hanno aumentato i loro sforzi di investimento prima di pubblicare i loro report finanziari.</p>
<p>I forti rapporti da parte di Microsoft e dalla società madre di Google, Alphabet, giovedì hanno spinto l’indice S&amp;P 500, l’aumento settimanale più grande dall’inizio di novembre dell’anno scorso. L’indice S&amp;P 500 è salito di circa il 7% nel 2024 e di circa il 24% dalla fine di ottobre dell’anno scorso.</p>
<p>Tuttavia, gli investitori sono stati colpiti anche dalle deludenti performance della società madre di Facebook, Meta Platforms, con il suo prezzo delle azioni che è sceso di oltre il 10% giovedì.</p>
<p>Lo stratega di Morgan Stanley ha dichiarato che il prezzo medio delle azioni delle società presenti nell’indice S&amp;P 500 di questo trimestre è stato solo dello 0,2% superiore alle aspettative degli analisti. Al contrario, i prezzi medi delle azioni delle società che non hanno soddisfatto le aspettative di profitto sono diminuiti del 4%, indicando una scarsa performance.</p>
<p>L’aumento dei rendimenti dei titoli di stato statunitensi potrebbe essere un altro fattore che influisce sugli investitori. Quando i rendimenti dei titoli salgono, le aspettative degli investitori sui futuri profitti delle aziende vengono influenzate in quanto ora possono ottenere rendimenti più elevati da titoli di stato privi di rischio. Con sempre più prove che mostrano che l’inflazione è più forte del previsto, il rendimento del titolo di stato di riferimento a 10 anni ha raggiunto il 4,74% questa settimana, il livello più alto dall’inizio di novembre dello scorso anno.</p>
<p>Con segni di forza economica e inflazione in aumento, l’aspettativa di tagli ai tassi di interesse è stata la principale forza trainante dietro la crescita del mercato azionario, ma questa aspettativa si è affievolita. Il mercato dei futures venerdì ha mostrato che gli investitori avevano solo un’aspettativa di riduzione dei tassi di interesse del 35 punti base nel 2024, mentre la valutazione di gennaio ha superato i 150 punti base.</p>
<p>Prima della riunione di politica della Federal Reserve prevista per questa settimana, i mercati azionari asiatici hanno aperto bene lunedì. Il mercato azionario asiatico è stato sostenuto lunedì dall’aumento delle azioni di Wall Street guidate dalle azioni tecnologiche venerdì scorso.</p>
<p>Venerdì la Banca del Giappone ha mantenuto invariati i tassi di interesse come previsto, ma non ha espresso alcuna preoccupazione significativa sul tasso di cambio. Il tasso di cambio yen-dollaro è sceso a 157,79 venerdì, un nuovo minimo in 34 anni, e per la prima volta in decenni il dollaro ha superato un livello psicologicamente critico di 160 yen, seppur brevemente. La maggior parte degli osservatori si aspetta che Tokyo agisca ora - l’ultima volta che è intervenuta è stata a settembre e ottobre 2022, quando il tasso di cambio del dollaro americano era rispettivamente intorno a 146,00 e 152,00 yen.</p>
<p>Anche altri paesi asiatici stanno diventando sempre più a disagio riguardo ai tassi di cambio. L’Indonesia ha alzato i tassi di interesse per far fronte alla debolezza della rupia, mentre Vietnam e India sono intervenuti direttamente sul mercato dei cambi per acquistare le proprie valute. Anche la Corea del Sud ha dichiarato che seguirà l’esempio.</p>
<p>In generale, la decisione di politica monetaria della Federal Reserve di mercoledì potrebbe indurre i mercati dei cambi e degli altri settori a rimanere cauti nei prossimi giorni. Il focus dell’economia asiatica di questa settimana include l’indice dei manager degli acquisti della Cina, i verbali della riunione della Banca di Corea, l’inflazione in Corea del Sud e Indonesia e il PIL di Hong Kong.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono scesi dell’1% a causa dell’impatto dei colloqui di cessate il fuoco tra Israele e Hamas, così come delle preoccupazioni per l’inflazione negli Stati Uniti. I futures del petrolio Brent sono scesi dell’1,1% a $88,50 al barile, mentre i futures del West Texas Intermediate (WTI) sono scesi dell’1% a $83,01 al barile.</p>
<p>Il prezzo di riferimento globale del petrolio greggio Brent è rimasto in gran parte invariato rispetto allo stesso periodo dell’anno scorso, a 81,76 dollari al barile. Ma l’aumento dei prezzi del petrolio significa che i profitti redditizi della raffinazione a partire dall’inizio di quest’anno diminuiranno. Total Energies prevede che la sua attività di raffinazione subirà una diminuzione dei profitti nel secondo trimestre e oltre a causa delle tensioni geopolitiche e delle restrizioni alla produzione dell’OPEC+.</p>
<p>L’oro è sceso dello 0,34% a $2.329,37 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 il riposting dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>