VHV0dG8gY2nDsiBjaGUgZGV2aSBzYXBlcmUgc3UgIkNyYXp5IElubm92YXRvciIgLSBXb3JsZGNvaW4=

<p><img src="https://gimg2.gateimg.com/blog/167999845218246089620230328-181352.jpeg" alt=""></p>
<h2 id="h2-TLDR560587"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Il 24 luglio 2023, l’economia dei token di Worldcoin è stata ufficialmente annunciata. Allo stesso tempo, diverse borse come Gate.io hanno anche lanciato con successo Worldcoin (WLD).</p>
<p>Sotto il bombardamento di numerosi messaggi, Worldcoin, un progetto ricco di sapore Cyberpunk, ha infiammato l’intero mondo delle criptovalute.</p>
<h2 id="h2-WorldCoin2020Innovatore20Pazzo824553"><a name="WorldCoin - “Innovatore Pazzo”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WorldCoin - “Innovatore Pazzo”</h2><p><img src="https://gimg2.gateimg.com/image/article/16909471445531690946512_.pic.jpg" alt=""></p>
<p>WorldCoin è un progetto di criptovaluta fondato da Sam Aitman nel 2020, che mira a costruire un protocollo finanziario open-source globale, equo e inclusivo.</p>
<p>La visione di WorldCoin è quella di creare il più grande e più equo sistema di identità digitale e valuta digitale al mondo, che possa ottenere l’autenticazione dell’identità scansionando l’iride di milioni di persone.</p>
<p>WorldCoin è composto da due entità principali: la WorldCoin Foundation e Tools for Humanity, le entità di sviluppo effettive. Il design di questo progetto è composto da tre componenti: WorldID, WorldCoin e un portafoglio (WorldAPP) che porta un ID di identità e una moneta.</p>
<p>WorldID: identità digitale basata sulla protezione della privacy e sulla prova di personalità.</p>
<p>–WorldCoin: Il primo token distribuito gratuitamente a livello globale, pianificato per essere distribuito a 1 miliardo di persone.</p>
<p>–WorldAPP: Un portafoglio per effettuare pagamenti, acquisti e trasferimenti in tutto il mondo.</p>
<p>Attraverso questi tre, gli utenti possono interagire con i token di WorldCoin, altri asset digitali e valute tradizionali per completare operazioni di pagamento, acquisto e trasferimento.</p>
<p>Per espandere rapidamente la propria rete finanziaria, WorldCoin prevede di distribuire gratuitamente il proprio token a 1 miliardo di persone in tutto il mondo. Tuttavia, il primo passo per raggiungere questo obiettivo è quello di prevenire gli “attacchi delle streghe”, in cui una persona controlla più indirizzi per trarne profitto (una misura comune dei tagliatori di coupon). Per questo motivo, WorldCoin ha scelto un metodo diretto, cioè verificare direttamente l’identità della persona reale.</p>
<p>Per raggiungere questo obiettivo, WorldCoin ha sviluppato un dispositivo biometrico chiamato Orb, che verifica l’unicità di una persona scansionando l’iride e utilizza la prova a conoscenza zero per garantire la sicurezza.</p>
<h2 id="h2-OrbPoPTutela20per20tutti19806"><a name="Orb+PoP=Tutela per tutti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Orb+PoP=Tutela per tutti?</h2><p>Anche se la scansione dell’iride potrebbe sembrare una preoccupazione per la privacy, secondo Worldcoin, ha già preso in considerazione questa problematica nel suo design.</p>
<p>Orb è un dispositivo hardware sferico sviluppato da Tools For Humanity. Utilizza la tecnologia di biometria dell’iride per verificare l’umanità e l’unicità di una persona in modo sicuro e rispettoso della privacy.<br><img src="https://gimg2.gateimg.com/image/article/16909472135541690946563_.pic.jpg" alt=""></p>
<p>Sotto la scocca, l’Orb è composto da due emisferi separati da una scheda madre e da potenti unità di elaborazione per un massimo di elaborazione locale. Tra di esse, la prima metà è dedicata ai sistemi ottici di sigillatura, mentre la seconda metà è dedicata ai sistemi di raffreddamento e agli altoparlanti. I suoi principali sistemi di imaging includono un obiettivo teleobiettivo e un sistema di gimbal 2D, un sensore di telecamera a otturatore globale e filtri ottici. Tra di essi, una lente mobile può aumentare il campo visivo di &gt;2 ordini di grandezza e più reti neurali controllano la cattura delle immagini. L’obiettivo teleobiettivo personalizzato utilizza vetro rivestito per ottimizzare la cattura delle immagini nello spettro del vicino infrarosso. La lente liquida integrata può ottenere un’autofocus automatico a livello di millisecondi, controllato da una rete neurale per ottimizzare la messa a fuoco. Il sensore dell’otturatore e l’illuminazione a impulsi sono sincronizzati per evitare sfocature.</p>
<p>In generale, puoi considerare Orb come uno strumento di scansione dell’iride. Dopo aver scansionato l’immagine dell’iride dell’occhio umano, il dispositivo Orb converte i dati dell’iride in un identificatore unico chiamato IrisHash, che viene completato in modo locale. Ciò significa che l’immagine originale dell’iride non verrà memorizzata o caricata. Questo identificatore unico IrisHash è un codice numerico breve memorizzato in un database per verificare se una persona è già registrata.<br><img src="https://gimg2.gateimg.com/image/article/16909472395551690946579_.pic.jpg" alt=""></p>
<p>Significa che Worldcoin non richiede la tua identità o informazioni personali, e la scansione di Orb conferma solo che tu sei l’unica persona reale, senza preoccuparsi di chi tu sia.</p>
<p>È una decisione di design importante, poiché Worldcoin può garantire a tutti di registrarsi una volta, nel rispetto della privacy dell’utente.</p>
<p>La biometria si è evoluta, compresa la riconoscimento facciale, il riconoscimento delle impronte digitali, i test del DNA, ecc., ma Worldcoin ha scelto l’iride principalmente a causa della sua unicità, prevenzione delle frodi e prestazioni. L’iride è più difficile da falsificare rispetto al viso e alle impronte digitali e, considerando che è necessario effettuare un’operazione di airdrop per 1 miliardo di persone, sia il confronto del database del riconoscimento facciale che il test del DNA, le prestazioni dell’iride sono più vantaggiose.</p>
<p>Una delle ragioni che impediscono all’industria crittografica di diventare il nucleo dell’economia virtuale globale è che il mondo crittografico manca di un sistema di credito e di istituzioni arbitrali, e i colpevoli possono utilizzare identità multiple per imbrogliare. Questo caos ha ostacolato lo sviluppo delle criptovalute. Pertanto, per garantire che l’industria crittografica possa svilupparsi in un’economia globale Web3, è necessario garantire che tutti possano ottenere una conferma di identità unica sulla blockchain. Questo può ridurre le frodi e i comportamenti maliziosi, aumentare la fiducia ed è anche il motivo per cui il DID è spesso indicato come un tracciamento di alta qualità con ampie prospettive di mercato.</p>
<p>WorldCoin utilizza il riconoscimento dell’iride per risolvere il problema dell’autenticazione unica dell’identità reale. Attraverso l’istituzione di un affidabile sistema di autenticazione dell’identità digitale, può ridurre i comportamenti malvagi, migliorare la fiducia e rendere il mercato crittografico più inclusivo e innovativo.</p>
<p>Inoltre, WorldCoin è impegnata anche nella governance globale e nella decisione di gruppo digitale. Molti progetti <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> adottano un modello di governance basato su token, in cui ogni token ha un voto. Sebbene questo modello raggiunga in parte la decentralizzazione e la democratizzazione, potrebbe escludere alcuni individui e favorire coloro che hanno maggior potere economico. Per affrontare questo problema, è necessario un meccanismo affidabile che possa resistere agli attacchi Sybil per semplificare l’implementazione di modelli di governance autonomi basati su identità umane uniche.</p>
<p>Il sistema di credenziali Proof of Personality (PoP) di WorldCoin è cruciale. Utilizzando PoP, WorldCoin ha raggiunto l’obiettivo di permettere alle persone di governare veramente il protocollo e garantire che tutti ne traggano beneficio. Questo meccanismo enfatizza il principio di “una persona, un voto”, permettendo a tutti di partecipare in modo equo al processo decisionale senza essere disturbati da identità duplicate.</p>
<h2 id="h2-Token20Economics437046"><a name="Token Economics" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token Economics</h2><p>Secondo il white paper ufficiale di Worldcoin, il limite di fornitura iniziale del token di governance di Worldcoin, WLD, è di 10 miliardi.</p>
<p>Il 75% di essi verrà assegnato alla comunità di Worldcoin, la maggior parte dei token verrà assegnata agli utenti e i token rimanenti verranno assegnati ai fondi dell’ecosistema e alle operazioni di rete;</p>
<p>B. 9.8% allocati al team di sviluppo iniziale;</p>
<p>C. 13,5% da assegnare agli investitori di Tools for Humanity;</p>
<p>D. Il restante 1,7% sarà riservato a Strumenti per l’Umanità.</p>
<p>La fornitura massima in circolazione al lancio di WLD è di 143 milioni. Tra questi, 43 milioni di WLD saranno assegnati agli utenti che hanno superato la convalida Orb nella fase di pre-lancio del progetto, e 100 milioni di WLD saranno prestati ai market maker al di fuori degli Stati Uniti.<br><img src="https://gimg2.gateimg.com/image/article/16909473325561690946596_.pic.jpg" alt=""></p>
<h2 id="h2-Modello20operativo20unico365542"><a name="Modello operativo unico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Modello operativo unico</h2><p><img src="https://gimg2.gateimg.com/image/article/16909473595571690946607_.pic_hd.jpg" alt=""></p>
<p>Gli operatori di Worldcoin si occupano principalmente dell’attuazione del progetto su scala globale.</p>
<p>Worldcoin recluta operatori da tutto il mondo, richiedendo loro di essere imprese legalmente registrate a livello locale, e dichiarando esplicitamente nei termini che non forniranno servizi ai residenti di altri paesi legalmente limitati come gli Stati Uniti, il che manifesta i rigorosi requisiti di conformità di Worldcoin. Dopotutto, raccogliere informazioni biologiche dai residenti locali è molto sensibile in qualsiasi paese.</p>
<p>Dopo che l’azienda ha presentato domanda per diventare un operatore, il team di Worldcoin entrerà nel processo di revisione e intervista, inclusa l’autenticazione KYC, la formazione sulla conformità e le regioni operative. Dopo aver fornito un set di equipaggiamento Orb, possono iniziare a lavorare.</p>
<p>L’operatore è principalmente responsabile di completare il lavoro di divulgazione scientifica e di scansione per gli utenti locali. Ogni volta che un operatore aiuta con successo un utente a completare la registrazione, riceveranno una certa quantità di Worldcoin come ricompensa. Questo è un meccanismo di incentivazione universale utilizzato per incoraggiare gli operatori ad aiutare attivamente più persone a registrarsi.</p>
<p>L’offerta totale di Worldcoin è di 10 miliardi, la stragrande maggioranza dei quali sarà fornita agli utenti e agli operatori. Per motivare i primi contributori, il numero di token ricevuti dagli utenti e dagli operatori per registrazione diminuirà nel tempo.</p>
<h2 id="h2-Come20possono20gli20utenti20partecipare20a20Worldcoin226608"><a name="Come possono gli utenti partecipare a Worldcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come possono gli utenti partecipare a Worldcoin?</h2><h3 id="h3-Scarica20lapp20World463246"><a name="Scarica l’app World" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scarica l’app World</h3><p><img src="https://gimg2.gateimg.com/image/article/16909473995581690946622_.pic.jpg" alt=""></p>
<p>Vai al sito ufficiale di Worldcoin（ <a href="https://worldcoin.org/download-app" rel="nofollow noopener noreferrer" target="_blank">https://worldcoin.org/download-app)</a>). Scarica e installa l’app World, uno strumento necessario per partecipare a Worldcoin o World ID. Attualmente, l’applicazione è compatibile con dispositivi Android e iPhone.</p>
<h3 id="h3-Registrare20un20account20personale192161"><a name="Registrare un account personale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Registrare un account personale</h3><p>Gli utenti possono registrarsi utilizzando un numero di telefono.</p>
<p>Dopo una registrazione riuscita, gli utenti possono anche scegliere di passare ad altri paesi o regioni.<br><img src="https://gimg2.gateimg.com/image/article/16909474355591690946655_.pic.jpg" alt=""></p>
<p>Dopo aver completato la registrazione, vedrai il tuo ID mondiale visualizzato in grigio, indicando che deve ancora essere convalidato. Ciò significa che non puoi ancora utilizzare l’applicazione World e devi eseguire l’autenticazione dell’iride.</p>
<h3 id="h3-Eseguire20lautenticazione20delliride903192"><a name="Eseguire l’autenticazione dell’iride" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eseguire l’autenticazione dell’iride</h3><p>Dopo esserti registrato con successo, l’utente deve continuare la convalida nell’applicazione World e fissare un appuntamento per l’autenticazione dell’iride di Orb. Puoi trovare un operatore Worldcoin nelle vicinanze nell’applicazione per l’autenticazione dell’iride. Nell’applicazione, puoi vedere le posizioni vicine per la selezione, ma è importante notare che è necessario prenotare in anticipo.</p>
<p>Quando si effettua un appuntamento, non è necessario compilare il vero nome, basta fornire informazioni che consentano al personale di confermare l’identità della persona che effettua la prenotazione.</p>
<p>L’intero processo di autenticazione dell’iride è molto veloce, impiegando solo 10 secondi per completarlo. (Assistito dal personale in loco)</p>
<p>Dopo aver completato l’autenticazione dell’iride, il tuo ID mondiale passerà da grigio a nero e mostrerà che sei pronto a utilizzare le funzionalità dell’app.<br><img src="https://gimg2.gateimg.com/image/article/16909474855601690946668_.pic.jpg" alt=""></p>
<h3 id="h3-Dietro20lautenticazione745986"><a name="Dietro l’autenticazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dietro l’autenticazione</h3><p>Il grafico seguente illustra i processi e le operazioni pertinenti dietro World App, Worldcoin, World ID e l’autenticazione Orb iris.<br><img src="https://gimg2.gateimg.com/image/article/16909475065611690946681_.pic.jpg" alt=""></p>
<p>In primo luogo, dopo che l’utente scarica l’applicazione World, l’applicazione genererà casualmente una <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Segreto</a> chiave.</p>
<p>Successivamente, gli utenti devono trovare operatori con le qualifiche di autenticazione Orb. L’autenticazione Orb è effettuata da personale reale che elabora i dati in loco e li firma, e i dati relativi alle immagini dell’iride verranno distrutti. I dati elaborati da Orb verranno caricati dopo la convalida.</p>
<h3 id="h3-Ricompense20di20autenticazione20di20Worldcoin964979"><a name="Ricompense di autenticazione di Worldcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricompense di autenticazione di Worldcoin</h3><p>Secondo le informazioni ufficiali di Worldcoin, gli utenti che completano l’autenticazione dell’iride dell’Orb riceveranno 25 token WLD (attualmente al prezzo di $2.46 per token) come loro primo (e unico) premio. Successivamente, gli utenti che si registrano e si autenticano riceveranno un premio di 1 WLD a settimana (che diminuirà nel tempo).</p>
<h2 id="h2-Dov20il20futuro722414"><a name="Dov’è il futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dov’è il futuro?</h2><p>Per quanto riguarda il progetto stesso, Worldcoin è senza dubbio un raro progetto hardcore nell’industria. Sia il design del proprio software che le capacità tecnologiche contenute nei suoi dispositivi hardware gli conferiscono la capacità di cambiare in certa misura le modalità esistenti.</p>
<p>Ma attualmente, il problema più grande che lo affronta è ancora la regolamentazione.</p>
<p>*”Il 28 luglio, secondo quanto riportato da Reuters, l’agenzia regolatoria francese sulla privacy ha annunciato di aver avviato un’indagine su Worldcoin e di fornire supporto ai dipartimenti competenti in Baviera per indagare su Worldcoin. Ritiene che ci siano questioni relative alla legalità della raccolta e conservazione dei dati biometrici di Worldcoin.”</p>
<p>Il 31 luglio, secondo Reuters, Michael Will, presidente dell’agenzia regolatoria dei dati tedesca, ha dichiarato che a causa del coinvolgimento di grandi quantità di dati biometrici sensibili, l’agenzia regolatoria dei dati tedesca sta indagando sul progetto Worldcoin dalla fine dello scorso anno. La nuova tecnologia adottata da Worldcoin presenta molti rischi, tra cui la questione se gli utenti acconsentano esplicitamente al trattamento dei loro dati biometrici altamente sensibili sulla base di informazioni ‘sufficienti e chiare’.</p>
<p>Si può immaginare che la ‘lotta’ tra Worldcoin e le agenzie regolamentari di tutto il mondo abbia appena iniziato, e questo è in realtà un microcosmo della prolungata guerra tra tecnologia ed etica (credo che Sam Aitman, come creatore di Chat GPT, non sia estraneo a questo). Pertanto, come bilanciare lo sviluppo tecnologico e la regolamentazione in futuro potrebbe essere la più grande proposta per Worldcoin.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Leo F.</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à consentita la ripubblicazione 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></div>