U2hpYmEgSW51IChTSElCKSBCcnVjaWEgb2x0cmUgODAgbWlsaW9uaSBkaSB0b2tlbiBtZW50cmUgaWwgY2FwbyBzdmlsdXBwYXRvcmUgYWNjZW5uYSBhIHVuIGNhbWJpbyBkaSByb3R0YSB2ZXJzbyBsJ0lB

<p><img src="https://gimg2.gateimg.com/image/article/1701767414SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR182717"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Il <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> La comunità ha bruciato oltre 80 milioni di SHIB il 18 novembre 2023.</p>
<p>Il prezzo del token Shiba potrebbe raggiungere $0.00001 nei prossimi giorni o settimane.</p>
<p>Shiba Inu pianifica di integrare l’AI nel suo ecosistema per migliorare l’esperienza di gioco degli utenti.</p>
<h2 id="h2-Introduzione124981"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La comunità <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> continua a introdurre misure per rafforzare il valore di SHIB, popolarmente noto come il <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> killer. Il memecoin, introdotto nel 2021, ha un grande seguito di investitori e fanatici. Stanno spingendo per lo sviluppo ulteriore della blockchain e il consolidamento del valore di SHIB.</p>
<p>Oggi, esamineremo le recenti bruciature di SHIB e la possibile integrazione dell’intelligenza artificiale (AI) sulla blockchain. Ci sar <a href="https://www.gate.io/price-prediction/shiba-inu-shib" target="_blank">previsioni attuali sul prezzo di Shiba</a>.</p>
<h2 id="h2-Shiba20Inu20Milestone20Pi20di208020milioni20di20token20bruciati449922"><a name="Shiba Inu Milestone: Più di 80 milioni di token bruciati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Shiba Inu Milestone: Più di 80 milioni di token bruciati</h2><p>Il 18 novembre, il tasso di combustione di Shiba Inu è aumentato del 60% in poche ore quando oltre 80 milioni di token sono stati inviati a un portafoglio senza uscita. Il motivo dell’aumento del numero di token Shiba bruciati è stato la notizia che la blockchain potrebbe integrare l’intelligenza artificiale.</p>
<p>L’attesa per l’introduzione dell’AI è seguita da un post da parte di uno degli sviluppatori di Shiba Inu su X. <a href="https://twitter.com/LucieSHIB/status/1719790454810558904" rel="nofollow noopener noreferrer" target="_blank">Shytoshi Kusama, il principale sviluppatore ha detto</a> Il’Intelligenza Artificiale decentralizzata è come una sinfonia di menti che lavorano insieme, dove ogni nota contribuisce alla melodia dell’innovazione, nessun singolo direttore, solo una collaborazione armoniosa.</p>
<p>Come per confermare la notizia dell’introduzione dell’IA sulla blockchain, Lucie, specialista di mercato di Shiba Inu, ha pubblicato lo stesso messaggio sul suo <a href="https://x.com/LucieSHIB/status/1725975158475608277?s=20" rel="nofollow noopener noreferrer" target="_blank">Profilo X</a> come mostra lo screenshot.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701767440SHIB 1.png" alt=""><br>Shiba Inu Suggerimenti sull’Integrazione dell’IA - X.com</p>
<p>Tornando alla questione degli 80 milioni di SHIB bruciati, 79.127.027 sono stati inviati in un portafoglio senza via di uscita in una singola transazione. Ci sono state anche altre 4 transazioni più piccole di circa 2,5 milioni ciascuna. Il seguente diagramma mostra la quantità totale di SHIB bruciati il 18 novembre.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701767471SHIB 2.png" alt=""><br>Tasso di combustione di Shiba Inu (SHIB) - ShibBurn.com</p>
<p>Tuttavia, l’evento di combustione non ha portato a un notevole aumento del prezzo, poiché il suo valore è rimasto bloccato intorno a $0.000008515. Il prossimo grafico mostra <a href="https://www.gate.io/price/shiba-inu-shib" target="_blank">prezzo di Shiba Inu</a> dopo l’evento dell’incendio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701767583SHIB 3.png" alt=""><br>Prezzo Shiba Inu - CoinGecko</p>
<p>Come si può notare dal diagramma, il prezzo di Shiba è diminuito tra il 19 e il 23 novembre, pochi giorni dopo l’evento di bruciatura. Alcune persone avevano previsto un aumento del prezzo di Shiba dato che la bruciatura dei token ha ridotto la sua offerta circolante.</p>
<p>In questo caso, ciò che lo sviluppatore principale di Shiba Inu, Shytoshi, <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a>, ha detto che ciò che è stato detto sulla distruzione dei token sembrava vero. Ha detto che bruciare i token non porta automaticamente ad un aumento del prezzo. Pertanto, secondo lui, il valore di un token aumenta solo attraverso l’uso e l’utilità.</p>
<p>Ha anche citato le attività dei ‘fudders’ come un fattore che fa scendere il prezzo di un token, anche se si è verificato un evento di burning. A tal proposito, ha detto che ‘gli attacchi dei fudders’ allontanano gli utenti o i partner, il che fa diminuire l’utilizzo’.</p>
<h2 id="h2-Altri20traguardi20dello20Shiba20Inu924622"><a name="Altri traguardi dello Shiba Inu" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altri traguardi dello Shiba Inu</h2><p>Oltre all’evento di bruciatura recente, la rete Shiba Inu ha raggiunto altri traguardi. Sono stati registrati miglioramenti in diversi indicatori chiave.</p>
<p>Ad esempio, la rete ha finora registrato un totale di 14.312.822 transazioni e 1.907.774 blocchi totali. Le sue transazioni giornaliere si attestano intorno ai 5,11 milioni. Inoltre, ha un totale di 1.277.580 indirizzi del portafoglio.</p>
<h2 id="h2-Esplorando20la20possibilit20il20potenziale20ingresso20di20Shiba20Inu20nellAI773295"><a name="Esplorando la possibilità: il potenziale ingresso di Shiba Inu nell’AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esplorando la possibilità: il potenziale ingresso di Shiba Inu nell’AI</h2><p>In precedenza, citando Shytoshi Kusama, abbiamo accennato all’integrazione di Shiba Inu con l’IA. Con questo, la blockchain integrerà la tecnologia dell’IA con il suo ecosistema di gioco play-to-earn (P2E). Ciò dimostra che il <a href="https://www.gate.io/learn/articles/what-is-shiba-inu-coin/23" target="_blank">comunità Shiba Inu</a>, incluso gli sviluppatori, si impegna a migliorare la sua esperienza utente.</p>
<p>L’integrazione dell’IA nell’ecosistema comporterà un’esperienza di gioco più coinvolgente e interattiva. Ciò probabilmente porterà a funzionalità dinamiche in-game e ad altre meccaniche di gioco adattive che miglioreranno la motivazione e il divertimento dei giocatori. Questo sviluppo arriva mesi dopo il lancio di <a href="https://www.gate.io/learn/articles/what-is-shibarium-blockchain/528" target="_blank">lo Shibarium, una soluzione di scalabilità di livello 2</a>.</p>
<h2 id="h2-Previsioni20del20prezzo20di20SHIB937941"><a name="Previsioni del prezzo di SHIB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsioni del prezzo di SHIB</h2><p>Prima di analizzare le previsioni di prezzo di SHIB per i prossimi mesi, concentriamoci prima sulla sua attuale pressione di vendita. <a href="https://app.intotheblock.com/coin/SHIB/deep-dive?group=exchanges&amp;subgroup=order-books&amp;chart=market-depth" rel="nofollow noopener noreferrer" target="_blank">Dati on-chain su IntoTheBlock</a> indica che il token Shiba sta affrontando una forte pressione venditrice. Le cifre aggregate dei libri degli ordini provenienti da varie criptovalute confermano questo.</p>
<p>In particolare, i dati aggregati del libro degli ordini mostrano che ci sono circa 3,5 trilioni di SHIB in vendita. D’altra parte, ci sono solo 2,7 trilioni <a href="https://www.gate.io/how-to-buy/shiba-inu-shib" target="_blank">Ordini di acquisto di SHIB</a>. Ciò indica che l’offerta di SHIB supera la domanda di circa 800 miliardi, poiché <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a> indica.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701767691SHIB 4.png" alt=""><br>Profondità di mercato on-chain dello scambio di Shiba Inu (SHIB) - IntoTheBlock</p>
<p>Il fatto che l’offerta di token Shiba sia attualmente maggiore della domanda rappresenta la possibilità di un grande sell-off che potrebbe innescare un calo dei prezzi. Ora, concentriamoci sui diversi <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a> permutazioni.</p>
<p>I dati esistenti mostrano che il prezzo del token Shiba è probabile che scenda da $0.000007. <a href="https://app.intotheblock.com/coin/AXS/deep-dive?group=financials&amp;chart=inAndOut" rel="nofollow noopener noreferrer" target="_blank">Dati on-chain su IntoTheBlock</a> mostra una crescente pressione ribassista. Purtroppo, se il prezzo dovesse scendere ulteriormente, è probabile che scenda al di sotto di $0.00006 come mostra il grafico Global In/Out of the Money (GIOM).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1701767746SHIB 5.png" alt=""><br>Dati globali di Shiba Inu (SHIB) In/Out of the Money (GIOM) - IntoTheBlock</p>
<p>Come mostra il diagramma, se le 52.9200 indirizzi che hanno acquistato 19,37 trilioni di SHIB a un prezzo massimo di $0,000007 offrono un forte supporto, il prezzo potrebbe non scendere al di sotto di quel livello. Tuttavia, se la pressione venditrice continua ad aumentare, il prezzo di SHIB potrebbe scendere verso $0,000004.</p>
<p>D’altra parte, se i tori esercitano molta pressione, il prezzo di SHIB potrebbe recuperare $0,00001. Tuttavia, quel livello potrebbe dimostrarsi difficile da raggiungere considerando che ci sono 153.700 indirizzi che hanno acquistato 68,5 trilioni di SHIB al prezzo medio di $0,000008. Se vendono le loro partecipazioni SHIB, il loro prezzo potrebbe ritracciarsi. Tuttavia, se il prezzo supera i $0,000008, potrebbe raggiungere $0,00001.’</p>
<h2 id="h2-Conclusione158401"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 18 novembre, la comunità Shiba Inu ha bruciato oltre 80 milioni di token in 5 transazioni. Nonostante la grande quantità di token bruciati, il loro prezzo non è aumentato. Invece, il loro valore è diminuito nei due giorni successivi. La notizia di una possibile integrazione dell’IA nell’ecosistema Shiba Inu ha promosso l’evento di bruciatura dei token.</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 repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>