SWwgcHJlenpvIGRpIEV0aGVyZXVtIChFVEgpIHJpY29ucXVpc3RhIGkgJDIsMksgYSBzZWd1aXRvIGRpIHVuIGF1bWVudG8gZGVsbCdhdHRpdml0w6AgZGkgcmV0ZSwgY29tZSByaXZlbGFubyBpIGRhdGk=

2023-12-05, 08:51

<p><img src="https://gimg2.gateimg.com/image/article/1701765390SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR391664"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Il prezzo di ETH ha superato i 2.000 dollari a novembre 2023.</p>
<p>Magic Eden e Yuga Labs stanno collaborando per lanciare un nuovo mercato ETH NFT.</p>
<p>Dal novembre il volume delle vendite NFT è aumentato, contribuendo a generare maggiori entrate per la rete Ethereum.</p>
<h2 id="h2-Introduzione519027"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’attesa dell’approvazione degli exchange traded fund (ETF) criptovalutari negli Stati Uniti continua a influenzare le performance dei prezzi di molte criptovalute. La moneta <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è una delle criptovalute che ha tratto molti benefici dall’entusiasmo per gli ETF. Questo è particolarmente vero considerando che BlackRock, la più grande società di gestione patrimoniale del mondo, <a href="https://www.gate.io/blog_detail/3499/blackrock-ether-etf-application-official" target="_blank">ha presentato una richiesta per un fondo negoziato in borsa di ETH</a>.</p>
<p>Questa analisi approfondisce <a href="https://www.gate.io/price/ethereum-eth" target="_blank">Recente performance dei prezzi della criptovaluta Ethereum</a> nonché le sue attività di rete generali. Discuteremo anche l’aumento delle transazioni Ethereum NFT e l’implicazione dell’esposizione al riciclaggio di denaro di Binance sul futuro di ETH e delle stablecoin.</p>
<h2 id="h2-Ethereum20supera20i20200020dollari20in20attesa20dellapprovazione20del20fondo20ETF20ETH789870"><a name="Ethereum supera i 2000 dollari in attesa dell’approvazione del fondo ETF ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum supera i 2000 dollari in attesa dell’approvazione del fondo ETF ETH</h2><p>Il 23 novembre, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Ethereum</a> superato i 2.000 dollari mentre il mercato <a href="https://www.gate.io/fr/blog_detail/3465/brief-surge-ethereum-fees-hits-100-post-blackrock-s-eth-filing" target="_blank">previsto l’approvazione dell’ETF ETH negli Stati Uniti</a>. L’altro fattore contributivo alla recente impennata dei prezzi è stato un miglioramento dell’attività di rete.</p>
<p>Sebbene ETH abbia ritestato il livello di supporto di $1.930 il 21 novembre, è salito sopra i $2.000 due giorni dopo. Durante la terza settimana del mese, il prezzo di ETH è aumentato del 2,5% mentre la sua capitalizzazione di mercato è cresciuta dello 0,5%. <a href="https://www.gate.io/learn/category/ethereum" target="_blank">Ethereum</a> Il trend al rialzo non è diminuito poiché il prezzo continua a salire costantemente.</p>
<p>Al 2 dicembre, il prezzo di Ethereum oscilla intorno ai $2.100 come indica il seguente diagramma.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701765699ETH Surge 1.png" alt=""><br>Movimento del prezzo di Ethereum - CoinGecko</p>
<p>Come puoi vedere nel diagramma, dal 10 novembre il prezzo di Ethereum è stato in trend sopra il livello di $1.930 per la maggior parte del tempo. Oltre all’attesa dell’approvazione degli ETF criptati, il miglioramento delle prestazioni delle applicazioni decentralizzate e l’aumento dell’attività NFT hanno contribuito alla sua impressionante performance.</p>
<h2 id="h2-Migliorata20lattivit20della20rete20Ethereum904985"><a name="Migliorata l’attività della rete Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Migliorata l’attività della rete Ethereum</h2><p>Diversi Ethereum dApps hanno registrato prestazioni impressionanti dall’inizio di novembre. Ad esempio, al 23 novembre il valore totale bloccato (TVL) delle dApps era di 26 miliardi di dollari, rappresentando un aumento del 5% rispetto alla settimana precedente.</p>
<p>In termini di TVL, la rete Ethereum è arrivata al secondo posto dietro a Binance Smart Chain ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>) come mostra la prossima immagine.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701765758ETH Surge 2.png" alt=""><br>Le migliori blockchain per numero di indirizzi attivi e DeFi TVL - DappRadar</p>
<p>La rete Ethereum ha generato anche molti ricavi durante novembre a seguito delle ottime prestazioni delle dApps. Anche se <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è molto più alta di Ethereum, le due blockchain generano entrate simili.</p>
<p>In particolare, il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ha una capitalizzazione di mercato di $728 miliardi mentre l’Ethereum ne ha $248 miliardi. Tuttavia, la rete bitcoin ha generato $57,5 milioni in commissioni di rete, mentre l’Ethereum ne ha incassati $54,3 milioni nella terza settimana di novembre. Si noti che il ricavo di Ethereum non include le commissioni da <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, protocolli Lido, Maker e altre piattaforme correlate.</p>
<h2 id="h2-Esplosione20degli20NFT20di20Ethereum475621"><a name="Esplosione degli NFT di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esplosione degli NFT di Ethereum</h2><p>L’aspettativa di un possibile approvazione di un ETF ETH negli Stati Uniti ha influenzato l’attività di Ethereum in vari modi. Ad esempio, durante la terza settimana di novembre c’è stato un notevole aumento del volume di NTF sulla rete. Un buon esempio è ciò che è accaduto tra il 23 e il 24 novembre.</p>
<p>Durante un periodo di 24 ore, la rete ha registrato un volume di vendite di NFT di 12,6 milioni di dollari. I dati on-chain disponibili su <a href="https://www.cryptoslam.io/blockchains/ethereum?tab=Top+NFT+Sales&amp;headerPeriod=30d" rel="nofollow noopener noreferrer" target="_blank">Cryptoslam conferma</a> un enorme aumento delle vendite di mercato NFT durante novembre. Indica che durante quel mese le vendite NFT sono aumentate di oltre il 56%. La seguente schermata mostra i dettagli.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701765953ETH Surge 3.png" alt=""><br>Volume delle vendite di NFT - Cryptoslam</p>
<p>Secondo Cryptoslam, gli NFT più popolari sono Bored Ape Yachts, Pudgy Penguins, Azuki e Crypto Punks. Sicuramente, i loro alti volumi di scambio hanno spinto verso l’alto il mercato ETH NFT.</p>
<p>Una tale performance indica che Ethereum rimane una blockchain preferita per i progetti NFT. Un altro possibile motore delle attuali prestazioni della rete Ethereum è la riduzione delle preoccupazioni normative legate all’ICO del 2015. Ora, il mercato ritiene che la SEC possa archiviare quella questione.</p>
<p>Inoltre, <a href="https://statics.ambcrypto.com/wp-content/uploads/2023/11/Dune-ETH.png" rel="nofollow noopener noreferrer" target="_blank">dati da Ambcrypto</a> indica che l’aumento del volume di vendita di NFT è iniziato a metà ottobre come mostra il grafico successivo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701765968ETH Surge 4.png" alt=""><br>Volume delle vendite di NFT - Ambcrypto</p>
<p>In altre notizie, Dappradar ha dichiarato apertamente che il trend negativo delle vendite di NFT è finito. <a href="https://dappradar.com/blog/dapp-industry-report-october-2023-dapps-defi-games-nfts" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Il trend al ribasso di un anno nel trading di NFT è stato interrotto.” Il commento di DappRadar è arrivato dopo che il mercato NFT ha registrato un aumento del 32% a ottobre.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">Previsione e previsione del prezzo dell’ETH per il 2025, 2030</a></p>
<h2 id="h2-Un20nuovo20mercato20NFT20allorizzonte800187"><a name="Un nuovo mercato NFT all’orizzonte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un nuovo mercato NFT all’orizzonte</h2><p>L’aumento delle vendite di NFT sulla rete Ethereum potrebbe essere correlato alla notizia blockchain di un possibile lancio di un marketplace NFT ETH. Magic Eden e Yuga Labs stanno collaborando per lanciare un nuovo marketplace NFT. L’obiettivo principale del marketplace è garantire che i creatori di NFT ricevano i diritti d’autore corretti.</p>
<p><a href="https://twitter.com/MagicEden/status/1720759076517265625" rel="nofollow noopener noreferrer" target="_blank">Magic Eden ha detto</a>, Siamo entusiasti di annunciare la nostra collaborazione con Yuga Labs per lanciare un nuovo mercato ETH entro la fine dell’anno. Questo sarà il primo grande mercato ETH a onorare le royalty dei creatori per tutte le collezioni ETH NFT. Senza i creatori, <a href="/web3" target="_blank" class="blog_inner_link">web3</a> non può esistere. Ecco a sostenere la creazione e la costruzione di un futuro migliore insieme.</p>
<p>Sia Yuga Labs che Magic Eden ritengono che un ecosistema NFT valido abbia bisogno del supporto di molti creatori di NFT. Senza creatori attivi e collaborativi, l’economia web3 potrebbe non prosperare come previsto.</p>
<p>Magic Eden ha promesso di condividere una parte della vendita del mercato secondario con i creatori, qualcosa che dovrebbe incentivare loro a essere più innovativi e creativi. La notizia del marketplace NFT è probabile che mantenga il momentum al rialzo dell’ETH per le prossime settimane o mesi.</p>
<h2 id="h2-Possibili20effetti20dellesposizione20del20riciclaggio20di20denaro20di20Binance20su20ETH20e20stablecoin112242"><a name="Possibili effetti dell’esposizione del riciclaggio di denaro di Binance su ETH e stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibili effetti dell’esposizione del riciclaggio di denaro di Binance su ETH e stablecoin</h2><p>L’ammissione di Binance di aver perpetrato il riciclaggio di denaro potrebbe avere un forte impatto su importanti criptovalute come ETH e stablecoin.</p>
<p>Per contesto, Binance e il suo fondatore Changpeng Zhao hanno ammesso di non aver implementato un programma efficace di contrasto al riciclaggio di denaro, il che ha consentito a individui soggetti a sanzioni degli Stati Uniti e a gruppi terroristici di utilizzare lo scambio di criptovalute.</p>
<p>Di conseguenza, Zhao e Binance hanno stipulato un accordo con il Dipartimento della Giustizia, la Commissione per il Commercio di Futures su Merci (CFTC) e il Dipartimento del Tesoro. Ai sensi dell’accordo, Binance è tenuta a pagare una multa di 4,3 miliardi di dollari.</p>
<p>Tuttavia, il mercato delle criptovalute è incerto sugli effetti dell’esposizione di Binance al riciclaggio di denaro sul settore. Anche se Binance rimane operativo, le cose potrebbero non essere mai più le stesse per il settore.</p>
<p>La chiusura o ridimensionamento del cripto scambio di Binance potrebbe avere implicazioni a lungo termine su criptovalute principali come ETH. Ad esempio, Binance è leader in termini di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Volume di trading spot. Poiché rappresenta circa il 30% dell’interesse aperto di tutti i contratti futures ETH, la chiusura dei derivati potrebbe portare a molti deflussi che potrebbero influire negativamente sulla loro liquidità.</p>
<p>Dopo l’ammissione di colpa di Binance, molti investitori di criptovalute hanno ritirato le proprie posizioni dalla borsa, causando una grande fuoriuscita. A meno che non ci siano segnali chiari che la situazione sia totalmente sotto controllo, più investitori di criptovalute potrebbero ritirare i propri asset criptati nei prossimi giorni e settimane.</p>
<p>Inoltre, la relazione tra <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT e Binance potrebbero portare le agenzie governative degli Stati Uniti ad accedere a dati precedentemente non divulgati relativi ai pagamenti in stablecoin per il riciclaggio di denaro e le organizzazioni terroristiche.</p>
<p>Pertanto, le agenzie governative degli Stati Uniti potrebbero analizzare le attività di varie banche e gateway di pagamento fiat che hanno collaborato con Binance durante diverse transazioni che hanno considerato illegali. Ciò potrebbe portare gli Stati Uniti e altri paesi ad adottare misure regolamentari contro i fornitori di stablecoin.</p>
<p>La rigorosa posizione regolamentare nei confronti di Binance e di altre importanti borse di criptovalute potrebbe influire significativamente sulle prestazioni di ETH. Questo perché Binance è la terza più grande <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">staker di ETH</a>, con oltre 1,24 miliardi di dollari di depositi. Tuttavia, il tempo dirà esattamente come le agenzie regolatorie degli Stati Uniti tratteranno la questione fino alla fine.</p>
<p>Leggi di più sugli aggiornamenti di ETH:<br><a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-the-ethereum-shapella-upgrade/518" target="_blank">Tutto quello che devi sapere sull’aggiornamento di Ethereum Shapella</a> <a href="https://www.gate.io/learn/articles/what-is-the-ethereum-shanghai-upgrade/460" target="_blank">Cos’è l’aggiornamento Ethereum Shanghai</a></p>
<h2 id="h2-Conclusion1546"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Come le altre principali criptovalute come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETH ha avuto una buona performance dal medio ottobre. Ha superato il livello di prezzo di $2.000 il 23 novembre. Al momento della stampa, <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">gli investitori possono comprare ETH</a> ad un valore di circa $2.100. Un aumento dell’attività di rete e delle prestazioni delle dApp hanno contribuito all’attuale momento al rialzo del prezzo della moneta Ethereum.</p>
<h2 id="h2-Domande20frequenti20su20Ethereum282128"><a name="Domande frequenti su Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Ethereum</h2><h3 id="h3-Qual20sar20il20prezzo20di20ETH20nel202025482230"><a name="Qual sarà il prezzo di ETH nel 2025?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual sarà il prezzo di ETH nel 2025?</h3><p>È probabile che Ether (ETH) scambi tra $1.404 e $4.596 con un prezzo medio di circa $3.192 nel 2025. Tuttavia, questo dipende da diversi fattori come le condizioni economiche globali, la geopolitica e la situazione di mercato esistente.</p>
<h3 id="h3-Cos20Ethereum488264"><a name="Cos’è Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Ethereum?</h3><p>Ethereum è una blockchain che ospita varie applicazioni decentralizzate. La sua moneta nativa, che guida l’intero ecosistema, è Ether (ETH). È la seconda criptovaluta per capitalizzazione di mercato.</p>
<h3 id="h3-Come20acquistare20ETH966198"><a name="Come acquistare ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare ETH?</h3><p>Puoi acquistare ETH su varie borse crittografiche decentralizzate e centralizzate come Gate.io. Per <a href="https://www.gate.io/buy_crypto?method=card&amp;fiat=USD&amp;type=buy&amp;crypto=USDT" target="_blank">acquista ETH sulla piattaforma di scambio Gate.io</a> dovresti finanziare un account verificato utilizzando qualsiasi altra criptovaluta principale e convertirla in ETH. In alternativa, puoi acquistare ETH tramite bonifico bancario, trading P2P e carta di credito / debito.</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 il punto di vista 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, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>