V29ybGRDb2luIGUgTlZpZGlhIHJhZ2dpdW5nb25vIHJlY29yZCBzdG9yaWNpIGEgY2F1c2EgZGVsbCdlbnR1c2lhc21vIHBlciBsJ0FJ

2024-03-05, 02:28

<p><img src="https://gimg2.gateimg.com/image/article/1709606331rdzz.jpeg" alt=""></p>
<h2 id="h2-Introduzione751031"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il mercato continua a vedere record mondiali di attività digitali nel mondo delle criptovalute. Una di queste innovazioni è WorldCoin, una criptovaluta sicura e universalmente accessibile, destinata a migliorare l’inclusività nel settore della blockchain.<br>In questo articolo, discutiamo degli obiettivi del team di WorldCoin attraverso il lancio del token. Ci concentreremo anche sulle tecnologie che supportano la moneta e su come qualsiasi persona con accesso a Internet e dati Wi-Fi può accedervi.</p>
<h2 id="h2-La20criptovaluta20WorldCoin20ha20registrato20un20notevole20aumento20di20prezzo146220"><a name="La criptovaluta WorldCoin ha registrato un notevole aumento di prezzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La criptovaluta WorldCoin ha registrato un notevole aumento di prezzo</h2><p>Il <a href="https://www.gate.io/how-to-buy/worldcoin-wdc &quot;price of WorldCoin (WDC" rel="nofollow noopener noreferrer" target="_blank">prezzo di WorldCoin (WDC)</a> WDC, una criptovaluta per il primo progetto di identità digitale alimentato da crittografia - fondato da Sam Altman - è aumentato di oltre il 40% durante un periodo di 24 ore che si è esteso dal 18 al 19 febbraio. Sam Altman, imprenditore e amante delle criptovalute, è il CEO di OpenAI, un’azienda di ricerca e sviluppo sull’IA. Al momento della stesura, WDC è scambiato a $7.89 dopo aver guadagnato il 240% nei 30 giorni precedenti, come mostra il seguente grafico.<br><img src="https://gimg2.gateimg.com/image/article/17096065351.png" alt=""><br>Movimento del prezzo di WorldCoin - <a href="https://www.coingecko.com/en/coins/worldcoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come osservato in <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a>, il prezzo della moneta mondiale ha iniziato a pompare il 15 febbraio, passando da $3,12 a $9,07 il 25 febbraio prima di ritracciarsi a $7,89. Al 22 febbraio la moneta WDC aveva guadagnato il 320% e aggiunto $840 milioni alla sua capitalizzazione di mercato in un periodo di 10 giorni</p>
<p>La causa principale dell’impennata del prezzo di WDC è stata il lancio di Sora, un’app di intelligenza artificiale che converte testo in video. Tuttavia, è importante notare che Sora non è collegato al token World Coin, se non per il fatto che Sam Altman, CEO di OpenAI - responsabile del lancio dell’app Sora AI - è il fondatore di WDC</p>
<p>Pertanto, World Coin sale in picchi a causa degli investitori di criptovalute che potrebbero desiderare esposizione a un token fondato da Sam Altman. Questo potrebbe essere dovuto alla reputazione di Altman e al suo track record di investimenti.</p>
<h2 id="h2-La20performance20di20altri20token20AI738571"><a name="La performance di altri token AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La performance di altri token AI</h2><p>Il World Coin (WDC) non è stato l’unico token AI che si è comportato bene durante il periodo citato. In realtà, diversi token AI come <a href="https://www.gate.io/price/singularitynet-agix" target="_blank">SingularityNET</a>, <a href="https://www.gate.io/trade/OCEAN_USDT" target="_blank">Oceano</a>, FetchAI (FET), Graph’s (GRT) e <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> Il valore di RNDR è aumentato di oltre il 17% in un giorno. Complessivamente, il valore della maggior parte di queste criptovalute è aumentato di oltre il 50% in una settimana.</p>
<h2 id="h2-Ragioni20per20il20pompaggio20del20prezzo20delle20monete20mondiali824443"><a name="Ragioni per il pompaggio del prezzo delle monete mondiali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ragioni per il pompaggio del prezzo delle monete mondiali</h2><p>La relazione finanziaria del quarto trimestre del 2023 di Nvidia è stata il catalizzatore dell’impennata dei prezzi di <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">alcuni token di intelligenza artificiale</a>. Il principale produttore di chip al mondo ha superato le aspettative, creando fiducia nel settore dell’intelligenza artificiale che ha aumentato i guadagni del token AI. In particolare, la forte domanda di prodotti correlati all’IA ha portato Nvidia a guadagnare oltre 22,1 miliardi di dollari.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1266/nvidia-fined-more-than-5-million-over-crypto-mining-disclosure" target="_blank">Nvidia multata oltre 5 milioni di dollari per la mancata divulgazione del mining di criptovalute</a></p>
<p>A causa di questo eccezionale rendimento finanziario c’è una rinascita dell’interesse nelle applicazioni di intelligenza artificiale e altre tecnologie. Questo potrebbe anche aver portato a una domanda maggiore di token di intelligenza artificiale rispetto prima.</p>
<p>Abbiamo già menzionato il <a href="https://www.gate.io/learn/articles/sora-emerges-will-2024-be-the-year-of-ai-web3-revolution/1942" target="_blank">contributo dell’applicazione Sora di OpenAI</a> all’attuale aumento dei prezzi dei token AI. In un’intervista con CoinDesk, <a href="https://www.coindesk.com/markets/2024/02/22/worldcoin-gains-40-hits-record-high-as-ai-tokens-surge-on-nvidia/" rel="nofollow noopener noreferrer" target="_blank">Strahinja Savic, il responsabile dei dati e dell’analisi presso FRNT Financial ha detto</a>, Il lancio di Sora di <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">OpenAI] e le impressionanti previsioni di vendita di Nvidia stanno alimentando un interesse più ampio [Ottimismo</a> circonda l’IA che si sta riversando nella cripto.</p>
<p>Savic ha aggiunto: “Abbiamo visto questo nel cripto in passato, dove i token legati a Metaverse hanno registrato una forte crescita quando Facebook ha cambiato il suo nome in Meta.”</p>
<p>L’aumento dell’adozione del progetto World Coin ha portato anche all’impennata del prezzo di WDC. Il progetto ha registrato molti nuovi indirizzi del portafoglio dall’inizio dell’anno, come mostra il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/17096067582.png" alt=""><br>Numero totale di detentori di Worldcoin - <a href="https://embed.santiment.net/chart?ps=worldcoin-org&amp;pt=WLD&amp;df=2023-09-18T00%3A00%3A00.000Z&amp;dt=2024-02-22T00%3A00%3A00.000Z&amp;emnm=1&amp;emcg=1&amp;wm=price_usd%3Bholders_distribution_total&amp;wax=0%3B1&amp;wc=%2326C953%3B%23FF5B5B&amp;ws=%7B%22interval%22%3A%221d%22%7D%3B" rel="nofollow noopener noreferrer" target="_blank">Santiment</a><br>Come si nota dal grafico, il numero totale di detentori di WDC coin è aumentato notevolmente dall’inizio dell’anno. In effetti, dall’inizio dell’anno al 23 febbraio sono state create un totale di 3.608 nuove adresse di portafogli di WDC coin, portando il totale a 13.800. La prossima immagine mostra i dati aggiornati sul sito web di World Coin.<br><img src="https://gimg2.gateimg.com/image/article/17096068613.png" alt=""><br>Numero di utenti su Worldcoin - <a href="https://worldcoin.org/" rel="nofollow noopener noreferrer" target="_blank">World Coin</a></p>
<p>Secondo <a href="https://worldcoin.org/" rel="nofollow noopener noreferrer" target="_blank">Sito web di World Coin</a> ci sono stati oltre tre milioni di iscrizioni. Sicuramente, con l’aumentare del numero di utenti, la domanda e il valore della moneta potrebbero aumentare. E ricorda che queste statistiche cambiano quotidianamente.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/worldcoin-wld" target="_blank">Previsione del prezzo di Worldcoin &amp; Prognosi per il 2024, 2025, 2030</a></p>
<h2 id="h2-Visione20di20World20Coin20Identificazione20digitale20decentralizzata20per20la20verifica20dellumanit20globale222500"><a name="Visione di World Coin: Identificazione digitale decentralizzata per la verifica dell’umanità globale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Visione di World Coin: Identificazione digitale decentralizzata per la verifica dell’umanità globale</h2><p>La visione di Worldcoin, una startup di identificazione digitale tramite scansione dell’iride, fondata da Sam Altman, Alex Blania e Max Novendstern, è quella di fornire un sistema di identificazione globale per dimostrare la ‘personhood’ al fine di contrastare i bot. La missione di Worldcoin è quella di generare identità digitali uniche per le persone e fornire una valuta digitale globale accessibile a ogni essere umano che abbia un servizio internet e un dispositivo adatto come uno smartphone.</p>
<p>Ogni essere umano che desidera creare la propria identità globale unica utilizzando il sistema World Coin dovrebbe utilizzare un dispositivo hardware chiamato Orb per scannerizzare il proprio iride, che ha un’impronta unica proprio come le impronte digitali. World Coin utilizza la copia dello scanner per generare l’identità unica della persona, il WorldID.</p>
<p>Curiosamente, chiunque nel mondo può unirsi a World Coin e creare la propria identità digitale unica. Il punto di partenza per il processo è scaricare l’app World.</p>
<h2 id="h2-Come20ottenere20incentivi20token515503"><a name="Come ottenere incentivi token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come ottenere incentivi token?</h2><p>La <a href="https://www.gate.io/blog_detail/3005/%E4%B8%80%E6%96%87%E8%AF%BB%E6%87%82%E7%96%AF%E7%8B%82%E7%9A%84%E5%8F%98%E9%9D%A9%E8%80%85-worldcoin" target="_blank">Worldcoin Orb distribuisce WDC</a> agli individui che hanno scannerizzato i loro occhi. Tuttavia, il progetto ha completato la fase Beta e distribuito il token a oltre 2 milioni di early adopter. Di conseguenza, World coin continuerà con la distribuzione di WDC dopo la fase di post-lancio.</p>
<h2 id="h2-World20Coin20Soars74484"><a name="World Coin Soars" class="reference-link"></a><span class="header-link octicon octicon-link"></span>World Coin Soars</h2><p>Come notiamo, è probabile che il prezzo di WDC continui a salire con l’aumento della domanda della moneta. Nel frattempo <a href="https://www.gate.io/how-to-buy/worldcoin-wld" target="_blank">gli investitori di criptovaluta possono acquistare token World Coin</a> su varie borse come <a href="https://www.gate.io/article/31525" target="_blank">Gate.io</a>, Binance e Coinbase.</p>
<h2 id="h2-Conclusion224594"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Durante il mese di febbraio, il token World Coin ha guadagnato molto a causa dell’aumento della domanda per la criptovaluta. Questo progetto è davvero unico poiché è il primo a creare un sistema di identificazione globale per dimostrare la “personalità” e offrire a molte persone l’opportunità di acquisire la sua moneta, WDC. Il progetto ha già completato la fase beta e presto inizierà la fase post-lancio.</p>
<h2 id="h2-Domande20frequenti20su20World20Coin846009"><a name="Domande frequenti su World Coin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su World Coin?</h2><h3 id="h3-Quanto20vale20120World20Coin574790"><a name="Quanto vale 1 World Coin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto vale 1 World Coin?</h3><p>1 World coin sta attualmente scambiando a $7.89. Tuttavia, il suo valore fluttua nel tempo. Ad esempio, il 15 febbraio 1 WDC valeva $3.12 mentre il 25 febbraio era scambiato a $9.07.</p>
<h3 id="h3-Cosa20fa20World20Coin866133"><a name="Cosa fa World Coin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa fa World Coin?</h3><p>World Coin crea identità digitali globali uniche che dimostrano la persona. Per generare un’identità digitale unica, un individuo dovrebbe scansionare la sua retina utilizzando l’app World.</p>
<h3 id="h3-Come20fare20soldi20con20World20Coin759566"><a name="Come fare soldi con World Coin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come fare soldi con World Coin?</h3><p>Ci sono diversi modi in cui gli investitori possono guadagnare con WDC. Possono acquistare e mantenere la moneta, scambiarla o aggiungere liquidità alle coppie che hanno il token. Un individuo può anche guadagnare denaro come operatore per l’individuo che si iscrive.</p>
<h3 id="h3-Quanto20vale20World20Coin20in20dollari533013"><a name="Quanto vale World Coin in dollari?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto vale World Coin in dollari?</h3><p>One World Coin vale $7.89 anche se potrebbe aumentare in futuro. Il prezzo di WDC è aumentato verso metà febbraio e ha mantenuto un alto valore da allora.</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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>