U2hpYmFyaXVtIHJhZ2dpdW5nZSBpbCB0cmFndWFyZG8gZGVpIDEwIG1pbGlvbmkgZGkgdHJhbnNhemlvbmkgcGVyIFNoaWJhIEludQ==

2023-06-12, 07:55

<p><img src="https://gimg2.gateimg.com/image/article/1686555966RDZZ.jpeg" alt=""></p>
<h2 id="h2-TLDR728944"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Il protocollo layer-2 Shibarium, recentemente lanciato, ha portato ad un elevato numero di transazioni del <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> token.</p>
<p>Più di 3 milioni di token Shiba sono stati bruciati solo nella terza settimana di maggio.</p>
<p>La comunità <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> ha implorato Twitter di integrare i token Shiba nel suo sistema di pagamento.</p>
<h2 id="h2-Introduzione555010"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il settore delle criptovalute, con migliaia di token/coin sul mercato, è uno degli industrie più competitive. Molti memecoin come <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a>, Floki Inu, PEPE e Shiba Inu sono asset essenziali nello spazio criptato. Alcune di queste memecoin stanno performando bene sul mercato nonostante non abbiano valori intrinseci. Questo articolo copre come Shiba Inu si è comportato durante il 2023 e l’impatto di Shibarium su di esso <a href="https://www.gate.io/price-prediction/shiba-inu-shib" target="_blank">prestazioni future dei prezzi.</a></p>
<h2 id="h2-Shibarium20raggiunge20il20traguardo20dei201020milioni20di20transazioni157126"><a name="Shibarium raggiunge il traguardo dei 10 milioni di transazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Shibarium raggiunge il traguardo dei 10 milioni di transazioni</h2><p>Il testnet Puppynet di Shibarium, la rete layer-2 di Shiba Inu, ha raggiunto un record di 10 milioni di transazioni durante la terza settimana di maggio. Un volume così elevato di transazioni è un segno che la domanda di token Shiba sta aumentando a causa della sua ampia base di utenti.</p>
<p>Shibarium è un <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain <a href="https://www.gate.io/blog_detail/357/essentials-for-crypto-newbie-what-is-layer-0-layer-1-and-layer-2" target="_blank">soluzione di scalabilità basata su layer-2</a> che si occupa dell’ecosistema Shiba Inu. Quello che il pubblico sta attualmente utilizzando è il testnet perché il team non ha ancora lanciato il mainnet. Tuttavia, la comunità Shiba Inu ha risposto positivamente allo sviluppo.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/shibarium-name-service-sns &quot;How to Buy Shibarium Name Service (SNS" rel="nofollow noopener noreferrer" target="_blank">Come acquistare il servizio di nome Shibarium (SNS)</a>”</p>
<p>I dati su Puppyscan mostrano che Puppynet ha registrato un volume di transazioni di 10,3 milioni e più di 921.214 blocchi durante la terza settimana di maggio. Le altre statistiche mostrano che la blockchain ha oltre 15 milioni di indirizzi del portafoglio e un tempo medio di blocco di 5 secondi. Dal 12 maggio, il protocollo registra una media di oltre 300.000 transazioni giornaliere.</p>
<h2 id="h2-Pi20di20320milioni20di20token20Shiba20Inu20bruciati20a20maggio917168"><a name="Più di 3 milioni di token Shiba Inu bruciati a maggio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Più di 3 milioni di token Shiba Inu bruciati a maggio</h2><p>Le altre statistiche interessanti riguardano il numero di token bruciati e l’aumento del tasso di bruciatura. Nella terza settimana di maggio sono stati bruciati oltre 3 milioni di token di Shiba Inu, il che si prevede che spingerà il suo prezzo al rialzo nel lungo termine.</p>
<p>Nonostante le recenti riduzioni, l’offerta circolante dei token Shiba rimane elevata poiché è ancora superiore a 589,3 trilioni. Inoltre, durante la seconda settimana di maggio, più di 5 milioni di SHIB sono stati bruciati. Le seguenti statistiche presentano un quadro chiaro della storia del bruciamento dei token Shiba.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556164Shibarium 1.png" alt=""><br>Statistiche di bruciatura di Shiba - Trackshib</p>
<p>Come mostra il diagramma, solo nel mese di maggio sono stati bruciati più di 13 trilioni di token Shiba. Inoltre, indica che finora sono stati bruciati oltre 410 trilioni di token.</p>
<h2 id="h2-La20comunit20sollecita20Twitter20a20integrare20Shiba20Token632443"><a name="La comunità sollecita Twitter a integrare Shiba Token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La comunità sollecita Twitter a integrare Shiba Token</h2><p>La comunità di Shiba Inu ha chiesto a Linda Yaccarino, il nuovo CEO di Twitter, di integrare il token Shiba nel suo sistema di pagamento, una mossa che aumenterebbe la sua domanda e, alla fine, il suo valore.</p>
<p>Ad esempio, Ragnar Shib, uno dei sostenitori più convinti del token Shiba, <a href="https://twitter.com/RagnarShiba/status/1657535845593755648" rel="nofollow noopener noreferrer" target="_blank">tweeted</a>, “Se hai problemi nell’integrare @Shibtoken su Twitter, faccelo sapere. Abbiamo la community più fedele, disponibile e numerosa nel mondo delle criptovalute.”</p>
<p>Sebbene non vi sia alcuna garanzia che Twitter renda il token Shiba parte del suo sistema di pagamento, l’esercito di Shiba spera in un tale passo. Questo perché Yaccarino segue l’account ufficiale di SHIB e gli account Twitter di molti altri progetti cripto. Di conseguenza, si suppone che Yaccarino possa essere interessato a Shiba Inu e ad altre memecoin.</p>
<h2 id="h2-Cos20Shibarium20e20come20influisce20sul20prezzo20del20token20Shiba598074"><a name="Cos’è Shibarium e come influisce sul prezzo del token Shiba?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Shibarium e come influisce sul prezzo del token Shiba?</h2><p>Abbiamo discusso di come il testnet di Shibarium abbia portato a un record di 10 milioni di transazioni per Shiba Inu. Parliamo brevemente di come funziona Shibarium e di come può contribuire alla crescita dell’ecosistema Shiba Inu.</p>
<p>Primariamente, Shibarium è un protocollo di Layer-2 che esiste sulla blockchain di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e si occupa dell’ecosistema Shiba Inu. Allo stesso modo, il <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">criptovaluta Shiba Inu</a> , con il token Shiba come criptovaluta nativa, opera anch’esso sulla stessa rete.</p>
<p>Il lancio di Shibarium porterà molti nuovi sviluppi sul progetto Shiba Inu. Ad esempio, avrà il suo scambio decentralizzato chiamato ShibaSwap e una piattaforma di metaverso e giochi.</p>
<p>Inoltre, Shibarium avrà <a href="https://www.gate.io/price/bone-shibaswap-bone" target="_blank">OSSO</a> come suo token di governance. Oltre a BONE, Shibarium avrà altre criptovalute che includono <a href="https://www.gate.io/trade/LEASH_USDT" target="_blank">LEASH</a>, TREAT e SHI. È essenziale notare che i validatori saranno ricompensati in BONE invece che in token Shiba.</p>
<p>Shibarium porta diversi vantaggi all’ecosistema Shiba Inu come la scalabilità, transazioni più veloci e commissioni di transazione basse. Questo perché elabora la transazione fuori catena, il che riduce la congestione. Le persone possono anche sviluppare applicazioni decentralizzate (Dapps) sulla blockchain di Shibarium.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/shiba-inu-shib &quot;How to Buy Shiba Inu (SHIB" rel="nofollow noopener noreferrer" target="_blank">Come acquistare Shiba Inu (SHIB) - HODL o scambiare criptovalute</a></p>
<h2 id="h2-Prestazioni20del20prezzo20di20Shiba20Token393402"><a name="Prestazioni del prezzo di Shiba Token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni del prezzo di Shiba Token</h2><p>Il token Shiba non ha avuto prestazioni come previsto nell’ultimo mese. In generale, <a href="https://www.gate.io/price/shiba-inu-shib" target="_blank">Prezzo del token Shiba</a> è diminuito del 15% a maggio causando perdite tra i trader. Il lancio di nuove memecoin come <a href="https://www.gate.io/price-prediction/pepe-pepe" target="_blank">PEPE</a> potrebbe aver contribuito alla scarsa performance del prezzo del token Shiba durante il mese.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556353Shibarium 2.png" alt=""><br>Movimenti dei prezzi di Shiba per maggio - Coingecko</p>
<p>Il grafico sopra dipinge chiaramente la performance dei prezzi dei token Shiba durante il mese di maggio. Come si può osservare, il prezzo è iniziato a scendere il 6 maggio fino alla fine del mese. Naturalmente, ci sono stati alcuni rimbalzi durante quel periodo.</p>
<p>Nonostante le scarse prestazioni del prezzo del token Shiba, ha guadagnato in altri aspetti. Secondo Glassnode c’è stato un <a href="https://studio.glassnode.com/metrics?a=SHIB&amp;category=&amp;m=addresses.NewNonZeroCount&amp;s=1684021022&amp;u=1684886400&amp;zoom=" rel="nofollow noopener noreferrer" target="_blank">Aumento del numero di nuovi portafogli</a> durante il mese. Il lancio previsto di nuovi prodotti sulla rete potrebbe aver portato ad un aumento del numero di indirizzi del portafoglio.</p>
<p>Le statistiche mostrano che il prezzo del token è stato in calo nei vari intervalli temporali come indicato nella tabella sottostante. Purtroppo, ciò dipinge uno scenario molto ribassista.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556417Shibarium 3.png" alt=""><br>Cambiamenti negativi dei prezzi di Shiba Inu - CoinGecko</p>
<p>Come osservato, il suo valore è diminuito del 15,2% negli ultimi 30 giorni, dello 0,5% negli ultimi 7 giorni e dello 0,7% nelle ultime 24 ore. Peggio ancora, il suo valore è diminuito anche del 25,8% nell’ultimo anno. Tuttavia, il mercato attende di vedere l’impatto delle recenti bruciature di token e l’introduzione di nuovi prodotti sul suo prezzo durante la seconda metà dell’anno.</p>
<h2 id="h2-Conclusione715561"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il token Shiba ha registrato un volume di transazioni di 10 milioni nella terza settimana di maggio. Nonostante questo sviluppo positivo, il token è rimasto in rosso per tutto il mese. Inoltre, durante quel periodo sono stati bruciati 3 milioni di token, qualcosa che potrebbe influenzare il suo prezzo in futuro.</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 fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>