TnVvdm8gbWluaW1vIHByZXp6byBkaSBFdGhlcmV1bT8gQ29zYSBzdWNjZWRlIHF1YW5kbyBCaXRjb2luIHBhc3NhIGEgUE9TPw==

2023-10-12, 07:43
<p><img src="https://gimg2.gateimg.com/image/article/1697095974SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR82041"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Da inizio anno, ETH ha registrato un aumento del prezzo del 36% anno su anno.</p>
<p>Il 20 settembre il prezzo dell’ETH ha raggiunto il suo punto più basso contro <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> negli ultimi 14 mesi</p>
<p>La regolamentazione delle criptovalute, la diminuzione del livello di concorrenza e l’approvazione degli ETF ETH potrebbero spingere il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Ethereum</a> su</p>
<h2 id="h2-Introduzione344742"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le relazioni tra i valori di diversi asset nella stessa categoria, come le criptovalute, possono darci indicazioni su come si sta evolvendo il mercato e le misure che possiamo prendere come investitori o aziende.</p>
<p>Oggi, analizziamo la relazione tra <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> e <a href="https://www.gate.io/learn/category/ethereum &quot;Ether (ETH" rel="nofollow noopener noreferrer" target="_blank">Ether (ETH)</a> Inoltre esploreremo la possibilità che la blockchain di Bitcoin passi dal meccanismo di consenso del proof-of-work a quello del proof-of-stake.</p>
<h2 id="h2-ETH20registra20un20aumento20del20prezzo20del203620dallinizio20dellanno285656"><a name="ETH registra un aumento del prezzo del 36% dall’inizio dell’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH registra un aumento del prezzo del 36% dall’inizio dell’anno</h2><p>Prima di esaminare la relazione tra i valori di BTC ed ETH, analizziamo i recenti e attuali movimenti dei prezzi dell’ETH. L’ETH ha registrato un aumento del prezzo del 36% anno su anno fino ad ora nel 2023 in termini di dollari statunitensi.</p>
<p>In confronto, questo è un buon rendimento di prezzo considerando che <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sta scambiando a circa il 66% in meno rispetto al suo massimo storico raggiunto nel novembre 2022. Il massimo storico del prezzo di Ether è di $4.870.</p>
<h2 id="h2-Confronto20dei20prezzi20di20ETH20e20Bitcoin379774"><a name="Confronto dei prezzi di ETH e Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Confronto dei prezzi di ETH e Bitcoin</h2><p>Possiamo anche valutare le performance del mercato ETH facendo un’analisi di Ethereum vs. <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">variazioni del prezzo del bitcoin</a>. Il 20 settembre il prezzo di ETH ha raggiunto il suo punto più basso rispetto a Bitcoin negli ultimi 14 mesi quando è sceso al di sotto del livello di supporto di 0,06 BTC.</p>
<p>Tuttavia, il mercato delle criptovalute non è a conoscenza delle cause esatte di tale caduta del prezzo di Ethereum. Il grafico seguente indica il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> vs. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo del Bitcoin</a> analisi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1697096098ETH  Price Low.png" alt=""><br>Confronto dei prezzi di ETH vs. Bitcoin - TradingView</p>
<p>Come mostra l’immagine sopra, il valore di ETH rispetto a bitcoin è in diminuzione da ottobre 2022. Tuttavia, come possiamo vedere, la situazione ha raggiunto un punto critico in quanto il valore di ETH ha recentemente superato il livello di supporto di 0,060 BTC, cosa che ha costretto il mercato delle criptovalute a interrogarsi sulle vere cause dell’attuale tendenza del prezzo di Ethereum.</p>
<p>La triste realtà è che la diminuzione attuale del prezzo di ETH si verifica sullo sfondo di varie modifiche infrastrutturali sulla blockchain che il mercato di ETH aveva previsto che avrebbero portato al rally della moneta.</p>
<p>Uno dei principali sviluppi sulla blockchain è stata la transizione di Ethereum dal meccanismo di consenso del proof-of-work a quello del proof of stake avvenuto a settembre 2022.</p>
<p>In sostanza, il mercato ETH aveva previsto che l’aggiornamento potesse creare un momento rialzista che potesse spingere <a href="https://www.gate.io/futures_info_new/futures/usdt/ETH_USDT" target="_blank">prezzo di Ether</a> sopra i 10.000 dollari. Questo perché l’aggiornamento ha ridotto il tasso di emissione di ETH.</p>
<p>A metà settembre 2022 il team di sviluppo di Ethereum ha annunciato che il tasso di emissione di ETH era diminuito a 0,25 della fornitura.</p>
<p>L’altro sviluppo rilevante della rete Ethereum è stato il lancio di Shapella Upgrade il 12 aprile 2023, che consente ai minatori di prelevare il loro ETH scommesso dal protocollo di staking nativo.</p>
<p>L’aggiornamento di Shapella ha risolto una preoccupazione chiave degli investitori di Ethereum. In precedenza, gli investitori di ETH erano preoccupati di dover bloccare le loro monete indefinitamente. Tuttavia, questo ostacolo è stato rimosso quando la blockchain ha lanciato l’aggiornamento di Shapella che ha permesso agli investitori di Ethereum di prelevare le loro <a href="https://www.gate.io/blog_detail/3103/analyzing-eth-price-impact-eth-staking" target="_blank">ETH staked</a>.</p>
<p>Dopo quel significativo traguardo di rete, il <a href="https://www.gate.io/bitwiki/detail/102/ethereum" target="_blank">Mercato dei ETH</a> Sperava in un aumento sostenuto del prezzo di Ethereum. Purtroppo, le cose non sono andate come previsto poiché il prezzo ha iniziato a diminuire. Ad esempio, il prezzo dell’ETH è sceso a $1,850 una settimana dopo l’aggiornamento di Shapella.</p>
<p>C’era qualcosa di notevole e anche inaspettato. Il mercato ETH aveva previsto di vedere un aumento dei prelievi netti di ETH dopo l’aggiornamento. Tuttavia, il contrario era vero. C’era <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">aumento del blocco di Ethereum</a> che ha portato a un afflusso netto di 3,1 milioni di ETH.</p>
<p>Poiché l’atteso aumento del prezzo di Ethereum è fallito, gli investitori di Ethereum e il resto del mercato delle criptovalute vogliono individuare potenziali catalizzatori per invertire la diminuzione del prezzo di Ethereum sperimentata da aprile.</p>
<h2 id="h2-Fattori20esterni20che20potrebbero20innescare20un20rally20dei20prezzi20di20Ethereum70868"><a name="Fattori esterni che potrebbero innescare un rally dei prezzi di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fattori esterni che potrebbero innescare un rally dei prezzi di Ethereum</h2><p>Il mercato ETH sta aspettando un catalizzatore per spingere il prezzo di Ethereum al rialzo. Il primo possibile catalizzatore è la vittoria schiacciante di Ripple sulla Securities and Exchange Commission (SEC) degli Stati Uniti.</p>
<p>Secondo la SEC, Ripple è colpevole di vendere il suo token ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) agli investitori istituzionali senza registrarla. Tuttavia, a luglio, il giudice Analisa Torres ha dichiarato che <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> non è un titolo quando viene venduto agli investitori al dettaglio sugli scambi di criptovalute.</p>
<p>In sostanza, ETH sta affrontando un destino simile a Ripple, qualcosa che ha demoralizzato gli investitori di Ethereum. Questo perché Ethereum ha venduto la sua moneta agli investitori istituzionali durante la sua pre-vendita. Ora, il mercato aspetta di vedere se la SEC prenderà di mira anche ETH come ha fatto con la criptovaluta Ripple (XRP). Se sia Ripple che ETH vengono autorizzati, ciò potrebbe fungere da catalizzatore per un aumento del prezzo di Ethereum.</p>
<h2 id="h2-Certezza20normativa20negli20USA39135"><a name="Certezza normativa negli USA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Certezza normativa negli USA</h2><p>La certezza normativa negli Stati Uniti e nelle altre economie leader potrebbe agire come un catalizzatore per un’impennata del prezzo di ETH. Ad esempio, non vi è alcuna chiarezza normativa riguardo all’offerta di monete iniziale (ICO) di Ether.</p>
<p>A proposito, il 20 settembre la rete Ethereum ha vissuto il primo movimento associato alla fase ICO. Infatti, 32,1 ETH acquisiti durante l’offerta iniziale di monete (ICO) di Ethereum sono stati trasferiti a Coinbase. Tuttavia, non vi è alcun incentivo per gli investitori di Ethereum simili a spostare le loro disponibilità di ETH basate su ICO per migliorare la liquidità nel mercato.</p>
<h2 id="h2-Notizie20positive20relative20alle20criptovalute239530"><a name="Notizie positive relative alle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie positive relative alle criptovalute</h2><p>Dalla nascita della valuta decentralizzata nel 2009, le notizie cripto hanno avuto un grande impatto sui prezzi delle criptovalute come ETH e bitcoin. Probabilmente, la migliore notizia cripto in grado di catalizzare l’aumento del prezzo di Ethereum riguarda i derivati ​​cripto. Ad esempio, l’approvazione degli Exchange Traded Funds (ETF) Ethereum potrebbe portare ad un’improvvisa impennata del prezzo di ETH.</p>
<p>Attualmente, il mercato ETH sta aspettando l’approvazione della SEC degli ETF ETH. L’approvazione degli ETF ETH probabilmente ridurrà il rischio associato alla concentrazione istituzionale in BTC.</p>
<p>L’altro notizie che possono avere un impatto positivo sul prezzo di Ethereum riguarda gli sviluppi che stanno avvenendo sulla blockchain. Come esempio, l’annuncio di Canto, una blockchain nativa di layer-1 di Cosmos, che si sta espandendo sulla blockchain di Ethereum, potrebbe influenzare il movimento verso l’alto del prezzo di ETH.</p>
<p>Canto, un rollup permissionless a conoscenza zero compatibile con la Ethereum Virtual Machine, porterà la finanza tradizionale nella rete Ethereum.</p>
<p>L’approvazione di <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">ETF Bitcoin</a> Anche l’aumento del prezzo di ETH può essere spinto. Questo è a causa dell’effetto di contagio del mercato delle criptovalute. In alcuni casi, <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">Movimento del prezzo di ETH</a> potrebbe riflettersi in quello del bitcoin.</p>
<h2 id="h2-Bassa20minaccia20da20reti20rivali653510"><a name="Bassa minaccia da reti rivali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bassa minaccia da reti rivali</h2><p>Se c’è una diminuzione della minaccia da parte delle blockchain rivali <a href="https://www.gate.io/price/ethereum-eth" target="_blank">Il prezzo di Ethereum potrebbe salire</a>. Un esempio specifico è quello di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Le catene che affrontano rischi simili relativi alle leggi ICO e sui titoli. Poiché hanno sfide simili, è meno probabile che mettano in discussione il dominio di mercato di ETH.</p>
<h2 id="h2-Il20meccanismo20di20consenso20ProofofStake20POS20di20ETH923093"><a name="Il meccanismo di consenso Proof-of-Stake (POS) di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il meccanismo di consenso Proof-of-Stake (POS) di ETH</h2><p>In precedenza abbiamo fatto riferimento al passaggio della blockchain di Ethereum dal meccanismo di consenso del proof-of-work al <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">proof-of-stake uno</a>. In parole semplici, il meccanismo di consenso proof-of-stake è un sistema decentralizzato che consente agli investitori della rete, che bloccano i loro token/coin, di verificare le transazioni sulla blockchain. In particolare, devono convalidare le transazioni delle persone che vendono o <a href="/how-to-buy/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">acquista Ethereum</a>.</p>
<p>Ad esempio, gli investitori di Ethereum che hanno scommesso l’ETH minimo richiesto possono verificare le transazioni sulla blockchain. Questo è diverso dal meccanismo di consenso del proof-of-work che la blockchain di bitcoin continua a utilizzare. In questo caso, i minatori devono verificare le transazioni delle persone che vendono o <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquistare Bitcoin</a>.</p>
<p>Con il PoW, i validatori delle transazioni, chiamati minatori, utilizzano la loro potenza di calcolo per risolvere complesse equazioni crittografiche. Lo svantaggio principale del PoW utilizzato dalla blockchain di Bitcoin è che il processo consuma molta energia. Tuttavia, il meccanismo di consenso PoW è più sicuro del <a href="https://www.gate.io/bitwiki/detail/46/proof-of-stake" target="_blank">PoS uno</a>.</p>
<p>Il motivo per cui alcune persone chiedono la transizione di bitcoin <a href="https://www.gate.io/blog_detail/897/%E5%B7%A5%E4%BD%9C%E8%AF%81%E6%98%8E-vs-%E6%9D%83%E7%9B%8A%E8%AF%81%E6%98%8E" target="_blank">da PoW a PoS</a> è quello di ridurre il consumo di elettricità. Tuttavia, il processo di transizione è complicato poiché è necessario un consenso tra i membri della comunità.</p>
<p><strong>Articoli correlati:</strong> <a href="https://www.gate.io/learn/articles/what-is-delegated-proof-of-stake/189 &quot;What Is Delegated Proof of Stake (DPoS" rel="nofollow noopener noreferrer" target="_blank">Cos’è Delegated Proof of Stake (DPoS)?</a>?“)<br><a href="https://www.gate.io/learn/articles/what-is-leased-proof-of-stake-and-how-does-it-work/374 &quot;What Is Leased Proof of Stake (LPoS" rel="nofollow noopener noreferrer" target="_blank">Cos’è Leased Proof of Stake (LPoS) e come funziona?</a> e come funziona?”</p>
<h2 id="h2-Il20futuro20di20Ethereum20e20del20mercato20pi20ampio20delle20criptovalute831303"><a name="Il futuro di Ethereum e del mercato più ampio delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il futuro di Ethereum e del mercato più ampio delle criptovalute</h2><p>In un prossimo futuro l’uso delle criptovalute dovrebbe aumentare poiché sempre più persone e istituzioni le accettano. Molte aziende accetteranno criptovalute principali come ETH e BTC come mezzo di pagamento. Questo è possibile grazie ai recenti lanci di efficienti gateway di pagamento che rendono molto facile per molte persone effettuare transazioni utilizzando criptovalute.</p>
<p>Inoltre, diversi governi potrebbero accettare importanti criptovalute come bitcoin e ETH come mezzo legale di pagamento. In passato, El Salvador e la Repubblica Centrafricana hanno designato <a href="https://www.gate.io/blog_detail/107/feature-bitcoin-as-fiat-money-good-move-by-el-salvador" target="_blank">bitcoin come mezzo di pagamento legale</a> Molte persone di questi paesi possono ora acquistare grandi quantità di bitcoin.</p>
<p>L’ascesa della finanza decentralizzata ( <a href="https://www.gate.io/blog_detail/136/what-is-defi-and-how-do-you-invest-in-its-top-product" target="_blank">DeFi</a>) ha permesso ai non bancarizzati o sottobancarizzati di accedere ai servizi finanziari. Pertanto, in futuro è probabile che il settore DeFi continui a crescere.</p>
<p>Ad esempio, il prestito e il prestito di criptovalute renderanno possibile per molte persone ottenere finanziamenti a basso interesse. Ciò porterà molte persone a comprare Ethereum da utilizzare come garanzia. <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">in diverse piattaforme DeFi.</a></p>
<p>È probabile che avremo anche più derivati crittografici come i fondi negoziati in borsa. Questi potrebbero aumentare l’adozione di criptovalute come ETH e bitcoin che potrebbero spingere i loro prezzi al rialzo.</p>
<h2 id="h2-Conclusione771667"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il prezzo della moneta Ethereum è costantemente diminuito da aprile 2023. Gli importanti aggiornamenti sulla blockchain come Shapella non sono riusciti ad aumentare la domanda di ETH. Tuttavia, <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">se la SEC approva gli ETF di ETH</a> il prezzo di Ethereum potrebbe salire.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore 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 repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards