RGVnZW4gQ2hhaW4gU2hhdHRlcnMgRXRoZXJldW0gRWNvc3lzdGVtIFJlY29yZHMgd2l0aCBVbnByZWNlZGVudGVkIFRQUyBSYXRlOiB1bidhbmFsaXNpIGFwcHJvZm9uZGl0YSBkZWxsYSBzdWEgdXRpbGl0w6AgZWNvbm9taWNhIGUgZGVsbGEgc2NhbGFiaWxpdMOg

2024-05-09, 02:06

<p><img src="https://gimg2.gateimg.com/image/article/1715219937rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR796318"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Tra il 18 e il 19 aprile la Degen Chain ha registrato 37,12 transazioni al secondo.</p>
<p>Alcuni esperti di criptovalute hanno avvertito di non fare affidamento sul conteggio TPS di una blockchain quando si valuta le prestazioni di una criptovaluta.</p>
<p>Il prezzo del token Degen è oscillato tra $0.02 e $0.04 durante le ultime due settimane.</p>
<h2 id="h2-Introduzione823474"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I memecoin sono diventati una delle principali classi di asset criptati. Al momento, i memecoin hanno una capitalizzazione di mercato totale di 51,1 miliardi di dollari, mostrando la loro crescente popolarità tra la comunità criptata. La cosa positiva è che ogni anno nuovi memecoin entrano sul mercato. Tuttavia, è emersa di recente una tendenza nel settore dei memecoin. Gli sviluppatori di questi token stanno aggiungendo loro utilità.</p>
<p>In questo articolo, esploriamo come il blockchain Degen <a href="https://www.gate.io/learn/articles/how-to-get-started-with-the-degen-eco-a-step-by-step-guide-to-operating-it/2555" target="_blank">supporta il token $DEGEN</a> che esiste sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Rete. Confronteremo anche le prestazioni di DEGEN ed Ethereum. Infine, daremo un’occhiata al <a href="https://www.gate.io/learn/articles/degen-on-base-network-dont-call-it-memecoin/2454" target="_blank">cause della popolarità di Degen tra gli amanti delle criptovalute</a>.</p>
<h2 id="h2-Impressionante20performance20di20Degen20nel202024413929"><a name="Impressionante performance di Degen nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impressionante performance di Degen nel 2024</h2><p>Degen Chain, una rete di livello Ethereum, ha registrato il conteggio più alto di transazioni al secondo (TPS) all’interno dell’ecosistema <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> durante il periodo di 24 ore che si è esteso dal 18 al 19 aprile. Il TPS di Degen Chain è aumentato di circa il 68,56% a un impressionante 37,12, superando quello di Base, una delle principali soluzioni di scalabilità sulla rete Ethereum, che ha raggiunto un TPS di 30,81 nello stesso periodo.</p>
<p><a href="https://l2beat.com/scaling/activity" rel="nofollow noopener noreferrer" target="_blank">I dati LBEAT mostrano</a> che la Degen Chain ha elaborato oltre 3,2 milioni di transazioni nel periodo di 24 ore. La tabella seguente riassume le prestazioni della Degen Chain e delle altre principali blockchain basate sulla rete Ethereum.<br><img src="https://gimg2.gateimg.com/image/article/17152200771.jpeg" alt=""><br>Record di TPS di ETH <a href="https://l2beat.com/scaling/activity" rel="nofollow noopener noreferrer" target="_blank">L2BEAT</a></p>
<p>Come osservato nella tabella sopra, la catena Degen ha ottenuto risultati migliori rispetto agli altri principali blockchain come zkSync Era, Arbitrum Orbit ed Ethereum. Nello specifico, negli ultimi 30 giorni la catena Degen ha elaborato un totale di 43,41 milioni di transazioni per diventare la quarta migliore blockchain, in questo senso, dietro Base, Linea e Arbitrum Orbit.</p>
<p>Non c’è dubbio che Degen Chain, un blockchain di livello 3 ad ultra basso costo che sfrutta Arbitrum Orbit e il livello di regolamento di Base per la scalabilità, si sia posizionato in modo competitivo nel settore della blockchain. Allo stesso modo, durante il periodo di 24 ore citato, la blockchain ha registrato un volume di scambi di oltre $819,600.</p>
<h2 id="h2-Confronto20con20i20valori20delle20transazioni20di20Ethereum20e20Base8535"><a name="Confronto con i valori delle transazioni di Ethereum e Base" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Confronto con i valori delle transazioni di Ethereum e Base</h2><p>Sebbene Degen sia scalabile grazie al suo elevato conteggio di transazioni al secondo (TPS), le altre metriche mostrano che Base ed Ethereum lo stanno superando in altre metriche.</p>
<p>Ad esempio, durante il periodo citato, Degen ha avuto un volume di scambi di soli $788,813, con un valore medio della transazione di circa $0,24. Al contrario, Ethereum e Base avevano valori medi di transazione più alti, rispettivamente $172 e $2,166. Questo contrasto rivela una debolezza della Degen Chain. La seguente tabella confronta le performance della Degen Chain e degli altri principali network.<br><img src="https://gimg2.gateimg.com/image/article/17152201242.jpeg" alt=""><br>Origine: <a href="https://twitter.com/syndicateio/status/1781004490302480607/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Come puoi vedere dall’immagine, Degen Chain e Immutable X hanno registrato un aumento percentuale maggiore in termini di conteggio TPS durante il periodo indicato. Un’altra cosa degna di nota è che la Degen Chain, con una capitalizzazione di mercato di $345 milioni, ha avuto un valore totale bloccato di $4,1 milioni entro il 19 aprile.</p>
<h2 id="h2-Critica20della20metrica20TPS192789"><a name="Critica della metrica TPS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Critica della metrica TPS</h2><p>Anche se la metrica TPS è ampiamente utilizzata nel settore delle criptovalute, alcuni esperti hanno messo in guardia dall’affidarsi eccessivamente ad essa. Il suo principale punto debole è che non tiene conto delle dimensioni computazionali di ciascuna transazione. Cointelegraph ha citato Steven Goldfeder, fondatore di Offchain Labs. <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">come dicendo</a>, “<br><strong>Utilizzare TPS è un po’ come contare il numero di banconote nel portafoglio, ma ignorando che alcune sono da un dollaro, alcune da venti e alcune da cento</strong>.”</p>
<p>Qui, Goldgeder sottolinea che quando confrontiamo le prestazioni della blockchain, non si tratta solo di un elevato conteggio delle transazioni al secondo; dobbiamo anche valutare la qualità delle transazioni.</p>
<h2 id="h2-La20popolarit20del20token20DEGEN20e20di20Degen20Chain164606"><a name="La popolarità del token DEGEN e di Degen Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La popolarità del token DEGEN e di Degen Chain</h2><p>Come accennato in precedenza, una delle principali ragioni per cui il token Degen è molto popolare è l’utilità economica che offre a Farcaster. In questa piattaforma di social media decentralizzata, è un token di mance. Allo stesso modo, quando gli sviluppatori hanno lanciato un airdrop per i membri della comunità di Degen che facevano parte anche degli ecosistemi di Base e Farcaster, <a href="https://www.gate.io/learn/articles/how-to-get-started-with-the-degen-eco-a-step-by-step-guide-to-operating-it/2555" target="_blank">la popolarità di DEGEN è aumentata</a>.</p>
<p>Farcaster è ben noto per Frames, una funzionalità che consente agli sviluppatori di creare mini-app interattive utilizzando la sua app, Warpcast. Le mini-app consentono agli sviluppatori di partecipare a attività come giocare ai giochi, creare NFT e effettuare transazioni senza lasciare l’ecosistema di Farcaster. DEGEN è un token di utilità utilizzato come mezzo di pagamento durante l’interazione con queste mini-app.</p>
<p>Inoltre, il token DEGEN viene utilizzato per premiare i membri della comunità di Farcaster per il loro coinvolgimento attivo sulla piattaforma. Alcuni membri della comunità premiano i creatori di contenuti, i costruttori di mini-app e altri utenti attivi attraverso la mance.</p>
<p>Oltre ad essere un token per mance, gli investitori possono anche partecipare al suo programma di mining di liquidità. Secondo <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">Pubblicazione Cointelegraph</a>, Thomas Tang, vice presidente degli investimenti di Ryze Labs - società di venture capital criptato - attribuisce la popolarità della Degen Memecoin alla sua utilità nell’ecosistema Farcaster. Lui <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">detto</a>“Ha guadagnato una grande popolarità di massa perché tutti si lasciano mance a vicenda e tutti lo tengono,”</p>
<p>In secondo luogo, DEGEN ha beneficiato dal <a href="https://www.gate.io/learn/articles/degens-impact-on-memecoin-eco/2589" target="_blank">effetto di rete che coinvolge le memecoins</a>. Come sapete, il token Degen è uno dei Memecoins che ha utilità grazie alle sue funzionalità come il supporto alle min-app sulla catena. Già, luminari della crittografia come Vitalik Buterin, il co-fondatore di Ethereum, hanno chiesto lo sviluppo e la promozione di meme coin che abbiano utilità.</p>
<p>In tal senso, <a href="https://vitalik.eth.limo/general/2024/03/29/memecoins.html" rel="nofollow noopener noreferrer" target="_blank">Buterin ha detto</a>, “Voglio vedere progetti divertenti di alta qualità che contribuiscono positivamente all’ecosistema e al mondo circostante (e non solo “portando utenti”) ottenere più attenzione.”</p>
<p>“Per lo meno, più Memecoin buone che cattive, idealmente quelle che supportano i beni pubblici invece di arricchire solo gli insider e i creatori. Ma anche idealmente, creare giochi invece di monete e realizzare progetti in cui le persone si divertono a partecipare.” Degen e BONK sono due esempi di Memecoin che hanno utilità.</p>
<h2 id="h2-Prestazioni20di20prezzo20del20token20DEGEN77473"><a name="Prestazioni di prezzo del token DEGEN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni di prezzo del token DEGEN</h2><p>Attualmente, DEGEN con una capitalizzazione di mercato di $327,198,024, sta scambiando a $0.02634 dopo aver perso il 8.6% nelle ultime 24 ore. Tuttavia, il prezzo di Degen è aumentato del 39.8% negli ultimi 30 giorni. È importante notare che dal 11 aprile il prezzo del token Degen è oscillato tra $0.02 e $0.04 come indica il seguente grafico.<br><img src="https://gimg2.gateimg.com/image/article/17152203103.jpeg" alt=""><br>Grafico dei prezzi di Degen Token per un mese - <a href="https://www.coingecko.com/en/coins/degen-base" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Ciò che vale anche la pena notare da <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a> è la curva in discesa che mostra il crescente momentum ribassista. L’altro fatto interessante è che il token ha raggiunto il suo massimo storico di $0.058950 il 31 marzo e il minimo storico di $0.00002274 il 15 gennaio. Guardando al futuro, la condizione di mercato di Degen è neutra poiché ha una lettura RSI di 40,22.</p>
<p>Tuttavia, la condizione di mercato neutra non è unica solo per Degen poiché ETH è nello stesso stato con una lettura RSI di 45,10. Il prezzo attuale dell’ETH è di $3.113,47 dopo una perdita del 4,5% nelle ultime due settimane. Tuttavia, alcune piattaforme analitiche come CoinCodex stanno indicando che il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo Ethereum</a> potrebbe rimanere piatto fino alla fine di maggio come segue <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a> l’indicatore grafico.<br><img src="https://gimg2.gateimg.com/image/article/17152203364.jpeg" alt=""><br>Grafico delle previsioni del prezzo di Ethereum - <a href="https://coincodex.com/crypto/ethereum/price-prediction/" rel="nofollow noopener noreferrer" target="_blank">CoinCodex</a><br>Come puoi vedere dal grafico, da metà aprile alla fine di maggio il prezzo di Ethereum potrebbe oscillare in un range stretto.</p>
<h2 id="h2-Conclusion909047"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La Degen Chain ha registrato un impressionante conteggio di transazioni al secondo (TPS) tra l’18 e il 19 aprile, superando altre blockchain leader sulla rete Ethereum. Tuttavia, alcuni analisti hanno avvertito che non è saggio valutare le prestazioni di una blockchain basandosi solo sul suo TPS in quanto ciò non tiene conto delle dimensioni computazionali di ciascuna transazione.</p>
<h2 id="h2-Domande20frequenti20su20Degen20Chain414224"><a name="Domande frequenti su Degen Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Degen Chain</h2><h3 id="h3-Dove20posso20comprare20Degen135539"><a name="Dove posso comprare Degen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove posso comprare Degen?</h3><p>Puoi comprare Degen Base su diverse borse centralizzate e decentralizzate come Gate.io, Bybit e <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>. Tuttavia, il miglior scambio per <a href="https://www.gate.io/how-to-buy/degen-token-dgn" target="_blank">acquista Degen Base su Gate.io</a> dove è abbinato contro USDT.</p>
<h3 id="h3-Cos20Degen20Token141164"><a name="Cos’è Degen Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Degen Token?</h3><p>Il token Degen è un token ERC20 che è stato distribuito alla comunità di Farcaster dove viene utilizzato per dare la mancia agli utenti attivi e ai creatori. Inizialmente, Degen è stato lanciato sulla blockchain di Ethereum ma ora ha la sua propria blockchain.</p>
<h3 id="h3-Come20acquistare20Degen20Base34310"><a name="Come acquistare Degen Base?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare Degen Base?</h3><p>Puoi facilmente comprare Degen Base su varie borse come Gate.io, Bybit e Uniswap. To <a href="https://www.gate.io/how-to-buy/degen--base--degen" target="_blank">acquista Degen Base su Gate.io</a>, apri e verifica il tuo account. Da lì puoi scambiare qualsiasi criptovaluta leader come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH a Degen.</p>
<h3 id="h3-Quanto20costa20Degen289341"><a name="Quanto costa Degen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto costa Degen?</h3><p>Al momento della scrittura, Degen è stato scambiato a $0.02634. Tuttavia, ha raggiunto il suo massimo storico di $0.058950 il 31 marzo e il minimo storico di $0.00002274 il 15 gennaio 2024.</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 ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, si intraprenderanno azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>