Q3J5cHRvIEJsYWNrIEhvcnNlIFdMRCByb21wZSBsJ2ltcGFzc2UgZSBkaXZlbnRhIHZpcmFsZSwgb3NpIHNlZ3VpcmxhPw==

2024-03-18, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/1710732798rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR852417"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>WLD, il primo token crittografico al mondo basato sul riconoscimento dell’iride, ha recentemente suscitato ampio interesse e discussione a causa dei suoi continui aumenti di prezzo vertiginosi. Le modifiche che la sua comparsa porterà nel campo della criptovaluta meritano l’attenzione di ogni investitore.</p>
<p>Worldcoin è un progetto che implementa il concetto di UBI. È composto da tre parti: World ID, Worldcoin e World APP.</p>
<p>Sebbene Worldcoin si trovi ancora di fronte a molte sfide nel breve termine, il suo potenziale rivoluzionario altamente immaginativo è particolarmente prominente nel campo delle applicazioni criptografiche e il suo gioco di valore sarà un processo a lungo termine.</p>
<h2 id="h2-Introduzione267030"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La nuova euforia narrativa dell’IA è ancora in corso, e il token Worldcoin (WLD), che è stato forzatamente legato al concetto di IA dalle persone, ha dominato la ricerca calda per quasi un mese. Anche il suo valore di mercato circolante totale ha superato una volta la valutazione di OpenAI. Come è stato emesso e lanciato questo progetto, se può staccarsi dagli attributi MEME e rilasciare vero valore UBI, e quali rischi e opportunità affronterà in futuro? Questo articolo ne discuterà insieme.</p>
<h3 id="h3-Risalendo20del2045620in20un20mese20Worldcoin20guida20il20settore20dellIA85015"><a name="Risalendo del 456% in un mese, Worldcoin guida il settore dell’IA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risalendo del 456% in un mese, Worldcoin guida il settore dell’IA</h3><p>Inconsciamente, Worldcoin è salito da $2,1 all’inizio di febbraio a circa $12 all’inizio di marzo, registrando un aumento in eccesso del 456% in appena un mese e diventando il token più caldo nel settore dell’AI.</p>
<p>Come mostrato nella figura, l’impennata di Worldcoin è strettamente legata alla dinamica di OpenAI.</p>
<p>Il 15 febbraio di quest’anno, OpenAI, un’azienda rinomata per ChatGPT, ha presentato al pubblico il suo ultimo sviluppo - un modello di generazione di video chiamato Sora. Questo modello è accattivante, in quanto può generare rapidamente video ad alta definizione di durata fino a un minuto con un semplice input di testo. Nel video, i personaggi sono diversi, le scene sono complesse e i dettagli dei personaggi sono vividi come se fossero nel mondo reale.<br><img src="https://gimg2.gateimg.com/image/article/17107326161.jpeg" alt=""><br>Sorgente: Gate.io</p>
<p>Questa notizia ha suscitato rapidamente accese discussioni sui social media, e il progetto blockchain di OpenAI - Worldcoin - è stato anche rapidamente acceso da questo sentimento, portando a una serie di solidi trend in salita. In pochi giorni, il prezzo di Worldcoin è raddoppiato e ha prontamente acceso la crescita di tutto il settore dell’intelligenza artificiale, mentre WLD ha continuato a dominare la serie di token popolari per quasi un mese.</p>
<p>Alla data di scrittura, il prezzo di Worldcoin si è leggermente ritirato a circa $10.5, e se calcolato sulla base di un’offerta totale di 10 miliardi di pezzi, il valore di mercato totale di WLD ha superato i $105 miliardi, che supera persino il 25% della valutazione più recente di OpenAI. Tuttavia, vale la pena notare che il tasso di circolazione di WLD è modesto, con solo il 1,49% del totale delle monete attualmente in circolazione sul mercato.</p>
<p>Secondo il sito ufficiale di Worldcoin, sono stati creati oltre 4,2 milioni di ID mondiali verificati Orb in oltre 120 paesi/regioni, con oltre 35 milioni di utenti e oltre 1 milione di utenti attivi a settimana.</p>
<p>Una così ampia base di utenti e una circolazione di token carente rendono naturalmente il token suscettibile a significative ipotesi speculative a breve termine.</p>
<h3 id="h3-Tentativo20di20idealizzazione20di20UBI284728"><a name="Tentativo di idealizzazione di UBI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tentativo di idealizzazione di UBI</h3><p>Il progetto blockchain di Worldcoin è stato concepito dai fondatori di OpenAI Sam Altman e Alex Blania nel 2020.</p>
<p>Dal 2021, Worldcoin ha attirato con successo investitori, tra cui a16z, DCG, Blockchain Capital, ecc., attraverso attività di finanziamento, raccogliendo oltre 100 milioni di dollari di capitale di rischio. La criptovaluta nativa di Worldcoin, WLD, è ufficialmente entrata nel mercato il 24 luglio 2023, facendo il suo debutto.</p>
<p>Il progetto mira a realizzare una grande visione di costruire il sistema di identità digitale e di valuta digitale globale più grande ed equo. In breve, il suo obiettivo è fornire criptovaluta gratuita e supporto economico diretto a ogni essere umano reale sulla Terra.<br><img src="https://gimg2.gateimg.com/image/article/17107326662.jpeg" alt=""><br>Origine: worldcoin.org/</p>
<p>Quindi, perché questo progetto è così generoso e disposto a distribuire la valuta gratuitamente al pubblico?</p>
<p>Questo deriva dalla profonda intuizione di Sam Altman che con lo sviluppo rapido della tecnologia dell’intelligenza artificiale, molti posti di lavoro sulla <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> potrebbero essere sostituiti dall’IA in futuro. Quando le persone perdono il loro lavoro, perdono anche una fonte stabile di reddito. Pertanto, è emerso il concetto di reddito di base (UBI).</p>
<p>Il progetto Worldcoin mira a realizzare questo concetto distribuendo il suo token di progetto - WLD - per fornire supporto economico a tutti. Questo token non è il tradizionale dollaro statunitense o l’oro ma una valuta digitale unica del progetto Worldcoin. Servirà come un “protocollo di identità digitale” nell’era dell’intelligenza artificiale, impegnato a costruire una soluzione decentralizzata di Proof of Humanity per portare benefici tangibili a tutti.</p>
<p>L’architettura di Worldcoin è composta da tre componenti principali:</p>
<ol>
<li><p>Un’identità globale - World ID: un’identità digitale utilizzata per proteggere la privacy</p>
</li><li><p>Una valuta digitale globale - Worldcoin: chiamata in codice WLD, disponibile solo per gli umani</p>
</li><li><p>Un portafoglio che porta con sé l’ID dell’identità e la valuta - World App: il primo portafoglio digitale compatibile con questo protocollo</p>
</li></ol>
<p>Nel concetto di Proof of Humanity, le opere ricche create dall’intelligenza artificiale sono spesso accompagnate da una grande quantità di contenuti spazzatura, quindi dimostrare l’autenticità e l’unicità di una persona diventa particolarmente importante.</p>
<p>A tal fine, Worldcoin pianifica di distribuire in tutto il mondo hardware dedicato chiamato Orb, consentendo alle persone di verificare la propria identità scansionando il loro iride e utilizzando specifiche applicazioni. Worldcoin enfatizza la sua tecnologia di protezione della privacy e pianifica di raggiungere gradualmente la decentralizzazione della governance del protocollo.</p>
<p>Nel meccanismo operativo di Worldcoin, gli utenti devono utilizzare l’applicazione World per generare chiavi private e pubbliche, e poi recarsi presso i dispositivi Orb vicini per verificare la propria identità tramite scansione dell’iride. Questo processo di verifica garantisce che solo individui umani veri possano superarlo, e ciascun individuo può essere verificato una sola volta. Una volta verificato con successo, l’utente riceverà l’ID World verificato da Orb.</p>
<h3 id="h3-Worldcoin20avanza20nel20mettere20in20discussione57880"><a name="Worldcoin avanza nel mettere in discussione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Worldcoin avanza nel mettere in discussione</h3><p>Molti prodotti innovativi affronteranno dubbi nelle prime fasi del lancio sul mercato, ma alcuni completeranno infine i test di stress e si dirigeranno verso l’ampio oceano di stelle. Ad esempio, sono <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e Worldcoin sta seguendo anche questa strada?</p>
<p>Una realtà comica è che Worldcoin stesso non è un progetto che utilizza la tecnologia dell’IA, e le persone associano solo forzatamente il fondatore di Worldcoin con OpenAI, eccitando vigorosamente il token, il che è effettivamente in linea con le caratteristiche di FOMO del mercato delle criptovalute.</p>
<p>Un altro punto di vista scettico è che Worldcoin abbia una maggiore importanza, ma a livello tecnico non ha mostrato punti di innovazione evidenti.</p>
<p>In particolare, il token WLD si basa su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il token ERC20 di Gate.io, che collabora con <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> sull’architettura sottostante e sicuro sull’account. ENS e <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> vengono utilizzati per trasferimenti e transazioni. L’unica tecnologia biometrica di scansione dell’iride con tecnologia nativa, Orb, è stata investigata dalle autorità di regolamentazione in paesi come Regno Unito, Francia e Germania a causa di problemi di privacy e sicurezza all’inizio del lancio del progetto. Recentemente, anche Spagna, Corea del Sud e altre regioni hanno iniziato a investigare sul suo divieto.</p>
<p>Tuttavia, Worldcoin non ha smesso di lavorare su un progetto di raccolta e pagamento di iris puro, e le sue azioni recenti sembrano fare affidamento sull’vantaggio di mercato del DID per espandere l’ecosistema.</p>
<p>Alla fine dell’anno scorso, la Fondazione Worldcoin ha annunciato un programma di finanziamento della comunità chiamato Wave0. Il piano prevede un finanziamento di 5 milioni di dollari suddiviso in tre categorie di finanziamento per consentire agli sviluppatori di concentrarsi sulla creazione di tecnologie adattabili e sistemi più equi sulla piattaforma Worldcoin.</p>
<p>Innanzitutto, il percorso di sovvenzione della comunità ha assegnato fino a 5000 WLD per sponsorizzazioni, hackathon e eventi simili. Inoltre, il percorso di sovvenzione del progetto mira a sostenere progetti su larga scala fino a 25000 WLD. Le sovvenzioni aperte si concentreranno sui progetti più importanti e ambiziosi senza un budget specifico e riceveranno importi basati su circostanze specifiche. Questa sovvenzione supporterà il lavoro di ricerca e sviluppo, in particolare quelli che esplorano l’intersezione tra privacy e biometria.</p>
<p>A marzo, il programma Wave0 ha annunciato il suo primo gruppo di candidati, con circa 800.000 WLD assegnati a 28 progetti in cinque continenti, che coprono soluzioni innovative per applicazioni World ID, protocolli World ID, agenti utente, nuove tecnologie hardware PoP e altro ancora. Questi includono Votexx, Zanzibar, NEBRA, Ribbon Protocol, xx Network, Rarimo, Wonderland, TheVoice, Wallfacer, Clade Club, Merkle Tree Explorer, RewardMe e altri ancora come IDMaster, ecc.<br><img src="https://gimg2.gateimg.com/image/article/17107327173.jpeg" alt=""><br>Origine: Worldcoin.org</p>
<p>Nell’onda dell’intelligenza artificiale, Worldcoin ha una grande visione e vede World ID come un mezzo chiave per raggiungere il Reddito di Base Universale (UBI) per tutti, il che è molto atteso. Tuttavia, allo stesso tempo, potenziali rischi e sfide, come la scansione dell’iride e la raccolta e conservazione dei dati biometrici, hanno anche suscitato preoccupazioni.</p>
<p>Sebbene Worldcoin affronti ancora molte sfide nel breve termine, il suo potenziale di rottura altamente immaginativo è particolarmente evidente nel campo delle applicazioni crypto. Questo potenziale successo e prospettiva di apprezzamento dei token ha attirato l’attenzione dei principali capitalisti di rischio di Silicon Valley, oltre al suo fondatore, Altman.</p>
<p>Con lo sviluppo esplosivo dell’IA, la domanda di sistemi che forniscono la prova di umanità, così come la domanda di sistemi di redistribuzione della ricchezza e di governance globale, sta crescendo.</p>
<p>Sam Altman è ancora impegnato a rendere questo progetto più accessibile al mondo reale e, in mezzo a controversie e prosperità, ci saranno comunque molti momenti salienti da vedere in questo progetto. Aspetteremo e vedremo anche.</p>
<p>Per gli investitori, il valore dei token WLD sarà profondamente influenzato dal riconoscimento del mercato del concetto di Worldcoin e dalla capacità del token di costruire scenari di applicazione pratici e un ecosistema dinamico. Questo gioco di consenso sarà a lungo termine e dovrebbe essere valutato in modo ragionevole quando si prendono decisioni di investimento mantenendo un concetto di partecipazione razionale.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 ri-pubblicare dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>