RXRoZXJldW0gKEVUSCkgc3VwZXJlcsOgIGkgMi4wMDAgZG9sbGFyaT8=

2023-07-03, 04:22
<p><img src="https://gimg2.gateimg.com/image/article/1688357706SDFX.jpeg" alt=""></p>
<h2 id="h2-TL20DR554107"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>L’aumento della quantità di ETH bloccato ha portato al prezzo stabile dell’ETH.</p>
<p>Durante la seconda settimana di giugno ETH ha consolidato la sua posizione intorno a $1,750.</p>
<p>Esiste una costante domanda di ETH dal momento che <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I trader mirano a scommettere su più monete.</p>
<p>Il mercato prevede che il valore di ETH aumenti verso i 2.000 dollari a giugno.</p>
<h2 id="h2-Introduzione991375"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>C’è stato un vivace dibattito sullo staking di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> a seguito del lancio del Protocollo EigenLayer che consente agli investitori di criptovalute di reinvestire i loro ETH. Il fatto che lo staking sia una delle migliori opportunità di investimento durante un mercato cripto depresso mostra quanto sia rilevante in questo periodo. Questo articolo discute lo stato attuale dello staking di Ethereum, le sue prospettive e l’eventuale impatto sull’intero mercato cripto.</p>
<h2 id="h2-Attivit20di20stake20di20Ethereum20in20aumento169368"><a name="Attività di stake di Ethereum in aumento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attività di stake di Ethereum in aumento</h2><p>Lo staking di Ethereum è aumentato nel corso del 2023 a seguito di diversi sviluppi come <a href="https://www.gate.io/blog_detail/2413/gate.io-market-watch-shapella-may-push-defi-innovation" target="_blank">l’aggiornamento Shapella</a> che è stato lanciato qualche mese fa. In effetti, l’obiettivo di questo aggiornamento è quello di incrementare lo staking di ETH che ha un’influenza positiva sul suo prezzo.</p>
<p>I dati su Nansen, una società di analisi on-chain, mostrano che la quantità di <a href="https://www.gate.io/blog_detail/2135/market-trend-rocket-pools-eth-staking-service-reaches-dollar1b-tvl" target="_blank">ETH staked</a> è aumentato significativamente nel secondo trimestre del 2023. Ciò indica che sono stati puntati quasi 23 milioni di dollari di ETH dopo il lancio dell’aggiornamento Shapella. Questo corrisponde a un aumento del 18% in un periodo di un mese. Il diagramma seguente mostra l’aumento di ETH puntato da aprile.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688357896unnamed (3" alt="">.png)<br>Aumento degli ETH staked - <a href="https://query.nansen.ai/public/dashboards/Hk93n66vsO0uvycfui8ypF2xcpNhpraxfwX5AWZJ?utm_campaign=shanghaiupgrade_12apr23&amp;utm_medium=social&amp;utm_source=twitter" rel="nofollow noopener noreferrer" target="_blank">Nansen</a></p>
<p>Come mostra l’immagine, il volume di ETH in staking continua a salire da aprile. Inoltre, secondo la metrica di Glassnode ‘Fornitura nei contratti intelligenti’, uno strumento che misura… <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">Attività di staking di Ethereum</a> attraverso vari protocolli monitorando la percentuale di ETH in circolazione, sono stati staked 360.000 monete ETH tra l’1 e il 12 giugno su vari smart contract DeFi e sulla catena Ethereum Beacon.</p>
<h2 id="h2-Effetto20di20un20aumento20di20ETH20in20staked20sul20suo20prezzo552219"><a name="Effetto di un aumento di ETH in staked sul suo prezzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effetto di un aumento di ETH in staked sul suo prezzo</h2><p>Se la maggior parte degli investitori ETH blocca le proprie monete per un lungo periodo, ciò funge da misura deflazionistica. Questo perché un aumento della quantità di ETH bloccato riduce il volume di monete circolanti, qualcosa che probabilmente porterà a un’azione positiva del prezzo di ETH.</p>
<p>Se ETH raggiunge un tasso di partecipazione allo staking del 60-70%, quale altro blockchain layer-1 di proof-of-stake <a href="https://www.gate.io/blog_detail/2210/cardano-ada-what-is-it-and-how-does-it-differ-from-bitcoin" target="_blank">come Cardano hanno</a>, significa che ci saranno circa 50-60 milioni di token ETH non staked. Ciò potrebbe ridurre significativamente la quantità di ETH sugli exchange. Ciò comporterebbe anche una diminuzione degli ETH disponibili per altri utilizzi come le commissioni di gas e altri scopi all’interno delle applicazioni decentralizzate (dApp). Questo potrebbe essere un possibile vento di poppa per il prezzo dell’ETH nel medio-lungo termine.</p>
<p>La riduzione dell’offerta circolante di ETH a causa del meccanismo di staking e di bruciamento, nonché la diminuzione del tasso di emissione di ETH a seguito della Fusione, che ha trasformato la blockchain di Ethereum dal meccanismo di consenso proof-of-work a quello proof-of-stake, probabilmente porterà al suo sostenuto movimento al rialzo del prezzo. Già secondo le recenti statistiche, l’offerta di ETH sta attualmente diminuendo di circa l’1,5% all’anno.</p>
<h2 id="h2-I20trader20di20criptovalute20si20stanno20preparando20per20acquisire20Ethereum20ETH792369"><a name="I trader di criptovalute si stanno preparando per acquisire Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I trader di criptovalute si stanno preparando per acquisire Ethereum (ETH)</h2><p>I libri degli ordini di criptovalute mostrano che il mercato ETH è rialzista poiché molti trader ETH sono <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">ordini di acquisto di Ethereum in accumulo</a> In particolare, le statistiche on-chain mostrano che i trader di ETH hanno recentemente piazzato ordini per acquistare 137.000 monete ETH mentre ce n’erano 122.000 in vendita, mostrando un deficit di 15.000.</p>
<p>In sostanza, i proprietari di ETH non sono disposti a vendere le proprie monete al prezzo di mercato prente poiché si aspettano che il suo valore aumenti in futuro. Vogliono bloccare le loro monete per guadagnare rendimento. La prevista pausa del tasso federale sta dando al mercato motivo per trattenere la propria criptovaluta. Come sappiamo, gli Stati Uniti dovevano annunciare il tasso della Fed il 14 giugno.</p>
<h2 id="h2-Pu20il20tasso20della20Fed20spingere20Ethereum20sopra20i202000783261"><a name="Può il tasso della Fed spingere Ethereum sopra i $2.000?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può il tasso della Fed spingere Ethereum sopra i $2.000?</h2><p>Immediatamente, il mercato delle criptovalute sta aspettando di vedere l’impatto del nuovo tasso della Fed sui prezzi delle varie criptovalute e altri asset di investimento correlati alle criptovalute.</p>
<p>Nonostante l’alta turbolenza di mercato proveniente dalla Securities and Exchange Commission degli Stati Uniti (SEC) <a href="https://www.gate.io/blog_detail/2448/cz-sued-cftu-another-turn-crypto-saga" target="_blank">querela contro</a> Binance e Coinbase, ETH ha consolidato la sua posizione intorno ai $1.750 durante la seconda settimana di giugno.</p>
<p>L’analisi dei dati on-chain indica che l’aumento del bloccaggio di ETH ha contribuito ad evitare un ritracciamento verso il basso del prezzo. In generale, ETH è stato resiliente alle recenti turbolenze nel mercato delle criptovalute che hanno portato altre criptovalute a perdere molto valore.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-ethereum-2-0/102" target="_blank">Cosa è Ethereum 2.0? Capire La Fusione</a></p>
<h2 id="h2-Previsione20del20prezzo20di20Ethereum376915"><a name="Previsione del prezzo di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione del prezzo di Ethereum</h2><p>L’annuncio atteso del tasso della Fed influenzerà il prezzo dell’Ethereum. Se c’è una pausa del tasso della Fed degli Stati Uniti, è probabile che vedremo un <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Ethereum</a> in rialzo verso i 2.000$. Tuttavia, ciò è possibile solo se ETH supera i 1.850$, che è il livello di resistenza iniziale e critico.</p>
<p>In base ai dati In/Out of The Money Around Price (IOMAP) di IntoTheBlock, alcuni analisti ritengono che i 3,38 milioni di investitori che hanno acquisito 10,97 milioni di ETH a un prezzo medio di $1.835 siano quelli che probabilmente scateneranno un pullback. L’immagine successiva riassume i dati su cui si basa la previsione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688358017unnamed (4" alt="">.png)<br>Previsione del prezzo di Ethereum (ETH), giugno 2023, IOMAP -<br><a href="https://app.intotheblock.com/coin/ETH/deep-dive?group=financials&amp;chart=inAndOut" rel="nofollow noopener noreferrer" target="_blank">IntoTheBlock</a></p>
<p>Tuttavia, una forte pressione ribassista potrebbe invalidare il momentum di ripresa dei tori ETH. Ciò è molto probabile che accada se il prezzo di ETH scende al di sotto del livello di supporto di $1.700. Tuttavia, i 1,23 milioni di investitori ETH che hanno acquistato circa 1,79 milioni di ETH al prezzo minimo di $1.700 potrebbero evitare ulteriori ribassi del suo valore.</p>
<p>Nel peggiore dei casi, se il prezzo scende al di sotto di $1.700, potrebbe esserci un crollo di ETH poiché il suo valore è probabile che ritracci verso $1.595.</p>
<h2 id="h2-Conclusione872906"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’aumento del volume di ETH staked ha impedito un significativo calo del valore della moneta nonostante l’attuale turbolenza del mercato crittografico. Di conseguenza, il prezzo di ETH ha oscillato intorno a $1.750. Tuttavia, c’è una forte possibilità che il prezzo di Ethereum superi i $1.850 e si avvii verso i $2.000.</p>
<h2 id="h2-Domande20frequenti20su20Ethereum482066"><a name="Domande frequenti su Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Ethereum</h2><p><strong>Fino a che punto può arrivare Ethereum?</strong></p>
<p>Si prevede che Ethereum raggiunga i 2.758 dollari nel 2023 se il mercato rimane rialzista. Tuttavia, il prezzo di ETH potrebbe salire a 100.000 dollari entro il 2035.</p>
<p><strong>È un buon periodo per <a href="/how-to-buy/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">acquista Ethereum</a>?</strong></p>
<p>Molti analisti ritengono che questo sia un buon periodo per comprare e tenere Ethereum poiché il suo prezzo dovrebbe aumentare se la sua pressione deflazionistica continua. L’aumento della quantità di ETH bloccato ridurrà la sua offerta circolante che potrebbe spingere il suo prezzo verso l’alto.</p>
<p><strong>Fino a che punto può arrivare Ethereum nel 2023?</strong></p>
<p>Il valore di Ethereum potrebbe raggiungere i 2.758 dollari nel 2023 se la sua domanda continua ad aumentare. Tuttavia, se fattori come l’aumento del tasso della Fed e una maggiore repressione delle attività legate alle criptovalute negli Stati Uniti continuano, il prezzo alla fine dell’anno potrebbe scendere al di sotto dei 2.758 dollari. Leggi anche le previsioni ETH per il 2023, il 2025 e il 2030.</p>
<p><strong>Può Ethereum crollare a zero?</strong></p>
<p>Ethereum è improbabile che crolli a zero se è ancora quotato su varie borse. Potrebbe crollare a zero se viene delistato da tutte le borse di criptovalute.</p>
<p><strong>Come acquistare ETH su Gate.io?</strong></p>
<p>Per acquistare ETH sulla piattaforma di scambio Gate.io, apri e verifica il tuo account. Una volta fatto ciò, visita la sezione ‘Acquista criptovaluta’ dove puoi pagare tramite carta di credito, trading P2P o bonifico bancario.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<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, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards